package cn.tfinfo.microservice.mes.konka.biz.stock;

import cn.hutool.core.bean.BeanUtil;
import cn.tfinfo.microservice.baseconstruct.constant.DateConstant;
import cn.tfinfo.microservice.baseconstruct.enums.BaseErrorCode;
import cn.tfinfo.microservice.baseconstruct.enums.Bool;
import cn.tfinfo.microservice.baseconstruct.lock.annotation.LockComponent;
import cn.tfinfo.microservice.baseconstruct.utils.CollectionUtils;
import cn.tfinfo.microservice.baseconstruct.utils.DateUtils;
import cn.tfinfo.microservice.baseconstruct.utils.StringUtils;
import cn.tfinfo.microservice.mes.basic.biz.dict.DictBo;
import cn.tfinfo.microservice.mes.basic.biz.serial.McComNumRuleBo;
import cn.tfinfo.microservice.mes.basic.biz.serial.RuleSerialBo;
import cn.tfinfo.microservice.mes.basic.biz.tooling.McMtmToolingBo;
import cn.tfinfo.microservice.mes.basic.common.annotation.PageList;
import cn.tfinfo.microservice.mes.basic.common.constants.DictType;
import cn.tfinfo.microservice.mes.basic.common.entity.base.BaseReturn;
import cn.tfinfo.microservice.mes.basic.common.entity.mtl.McMtlMaterialEntity;
import cn.tfinfo.microservice.mes.basic.common.entity.mtl.McMtlTypeEntity;
import cn.tfinfo.microservice.mes.basic.common.entity.mtm.McMtmSerialmtlEntity;
import cn.tfinfo.microservice.mes.basic.common.entity.serial.SerialResultEntity;
import cn.tfinfo.microservice.mes.basic.common.entity.serial.SubLotEntity;
import cn.tfinfo.microservice.mes.basic.common.entity.stock.MpInvMtlLocEntity;
import cn.tfinfo.microservice.mes.basic.common.entity.tooling.McMtmToolingEntity;
import cn.tfinfo.microservice.mes.basic.common.enums.BaseNum;
import cn.tfinfo.microservice.mes.basic.common.enums.MpInvMtlLocStateEnum;
import cn.tfinfo.microservice.mes.basic.common.enums.OperatorTypeEnum;
import cn.tfinfo.microservice.mes.basic.common.enums.ParamUnitEnum;
import cn.tfinfo.microservice.mes.basic.common.utils.DateUtil;
import cn.tfinfo.microservice.mes.basic.common.utils.TimeUtils;
import cn.tfinfo.microservice.mes.basic.persistance.dao.mtl.McMtlMaterialDao;
import cn.tfinfo.microservice.mes.basic.persistance.dao.mtl.McMtlTypeDao;
import cn.tfinfo.microservice.mes.konka.biz.api.HtApiResponse;
import cn.tfinfo.microservice.mes.konka.biz.api.HtWmsApiBo;
import cn.tfinfo.microservice.mes.konka.biz.chemBackUp.McMtmSerialmtlBo;
import cn.tfinfo.microservice.mes.konka.biz.chemType.McMtmMaterialParamBo;
import cn.tfinfo.microservice.mes.konka.biz.mtl.MaterialSerialAndGroupBO;
import cn.tfinfo.microservice.mes.konka.biz.user.UserBo;
import cn.tfinfo.microservice.mes.konka.biz.user.UserUtil;
import cn.tfinfo.microservice.mes.konka.common.annotation.LockFunctionNew;
import cn.tfinfo.microservice.mes.konka.common.constants.BizDictType;
import cn.tfinfo.microservice.mes.konka.common.dto.htWmsApi.HtWmsMtlOutDtlItemRequestDTO;
import cn.tfinfo.microservice.mes.konka.common.dto.htWmsApi.HtWmsMtlOutDtlRequestDTO;
import cn.tfinfo.microservice.mes.konka.common.dto.htWmsApi.HtWmsMtlOutRequestDTO;
import cn.tfinfo.microservice.mes.konka.common.dto.htWmsApi.HtWmsResponseDTO;
import cn.tfinfo.microservice.mes.konka.common.dto.htWmsCtr.HtWmsMoveInfoDTO;
import cn.tfinfo.microservice.mes.konka.common.dto.htWmsCtr.HtWmsMoveOrderDTO;
import cn.tfinfo.microservice.mes.konka.common.dto.htWmsCtr.HtWmsMoveOrderItemDTO;
import cn.tfinfo.microservice.mes.konka.common.dto.htWmsCtr.MpInvActivityMoveInfoHtWmsDto;
import cn.tfinfo.microservice.mes.konka.common.entity.chemType.McMtmMaterialParamEntity;
import cn.tfinfo.microservice.mes.konka.common.entity.config.DeptEntity;
import cn.tfinfo.microservice.mes.konka.common.entity.entity.McMtmTemperatureEntity;
import cn.tfinfo.microservice.mes.konka.common.entity.eqp.HtEqpMtlDTO;
import cn.tfinfo.microservice.mes.konka.common.entity.htorder.HtOrderInfoEntity;
import cn.tfinfo.microservice.mes.konka.common.entity.htwms.HtWmsLnMtlAlyOrderDEntity;
import cn.tfinfo.microservice.mes.konka.common.entity.htwms.HtWmsMaterialInfoEntity;
import cn.tfinfo.microservice.mes.konka.common.entity.mtl.temperature.MaterialSerialAndGroupInfoEntity;
import cn.tfinfo.microservice.mes.konka.common.entity.mtl.temperature.MaterialSerialAndGroupQueryEntity;
import cn.tfinfo.microservice.mes.konka.common.entity.mtl.temperature.MaterialSerialOrGroupParamEntity;
import cn.tfinfo.microservice.mes.konka.common.entity.mtl.temperature.MpInvMtlLocEntityExetend;
import cn.tfinfo.microservice.mes.konka.common.entity.stock.*;
import cn.tfinfo.microservice.mes.konka.common.enums.*;
import cn.tfinfo.microservice.mes.konka.common.utils.MesDateUtils;
import cn.tfinfo.microservice.mes.konka.persistance.dao.htorder.HtOrderInfoDao;
import cn.tfinfo.microservice.mes.konka.persistance.dao.htwms.HtWmsBaseDao;
import cn.tfinfo.microservice.mes.konka.persistance.dao.htwms.HtWmsLnMtlAlyOrderDao;
import cn.tfinfo.microservice.mes.konka.persistance.dao.lot.MpLotDao;
import cn.tfinfo.microservice.mes.konka.persistance.dao.mtl.temperature.MaterialserialAndGroupDao;
import cn.tfinfo.microservice.mes.konka.persistance.dao.stock.*;
import cn.tfinfo.microservice.mes.konka.persistance.dao.workorder.MpWorkorderDao;
import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.RowBounds;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

import static cn.tfinfo.microservice.mes.basic.common.constants.AdBillnoRuleConstant.INVSUBLOT;
import static cn.tfinfo.microservice.mes.basic.common.enums.BaseSysCode.DATA_ALREADY_BE_UPDATED;
import static cn.tfinfo.microservice.mes.basic.common.enums.BaseWhether.NO;
import static cn.tfinfo.microservice.mes.basic.common.enums.BaseWhether.YES;
import static cn.tfinfo.microservice.mes.basic.common.enums.InvActivityTypeEnum.*;
import static cn.tfinfo.microservice.mes.konka.common.constants.CtlParamTypeConstant.*;


/**
 * @Description: 线边仓物料-移料业务层
 * @Author: ezio
 * @Date: 2025/04/19 14:16:33
 */
@LockComponent
@Slf4j
public class MpMtlMoveHtWmsBo extends MpMtlBaseHtWmsBo {

    /**
     * 工治具档案业务层
     */
    @Autowired
    private McMtmToolingBo mcMtmToolingBo;

    /**
     * 单件物料档案（化学品）业务层
     */
    @Autowired
    private McMtmSerialmtlBo mcMtmSerialmtlBo;

    /**
     * 线边仓物料-移料持久层
     */
    @Autowired
    private MpMtlMoveDao mpMtlMoveDao;

    /**
     * 物料活动持久层
     */
    @Autowired
    private MpInvActivityDao mpInvActivityDao;

    /**
     * 物料活动明细持久层
     */
    @Autowired
    private MpInvActivityDtlDao mpInvActivityDtlDao;

    /**
     * 物料活动序列持久层
     */
    @Autowired
    private MpInvActivitySnDao mpInvActivitySnDao;

    /**
     * WMS物料条码-物料活动序列持久层
     */
    @Autowired
    private MpInvActivitySnHtWmsDao mpInvActivitySnHtWmsDao;

    /**
     * 物料位置持久层
     */
    @Autowired
    private MpInvMtlLocDao mpInvMtlLocDao;

    /**
     * 物料库存持久层
     */
    @Autowired
    private MpInvMtlGroupDao mpInvMtlGroupDao;

    /**
     * 批号序列号规则业务层
     */
    @Autowired
    private McComNumRuleBo mcComNumRuleBo;

    /**
     * 流水号生成类
     */
    @Autowired
    private RuleSerialBo ruleSerialBo;

    /**
     * 物料库存参数持久层
     */
    @Autowired
    private MpInvMtlGroupParamDao mpInvMtlGroupParamDao;

    /**
     * 用户工具类
     */
    @Autowired
    private UserUtil userUtil;

    /**
     * 批次dao
     */
    @Autowired
    private MpLotDao mpLotDao;

    /**
     * 工单dao
     */
    @Autowired
    private MpWorkorderDao mpWorkorderDao;

    /**
     * u8-WMS接口
     */
    @Autowired
    private HtWmsApiBo htWmsApiBo;


    /**
     * 订单查询
     */
    @Autowired
    private HtOrderInfoDao htOrderInfoDao;

    /**
     * WMS需要的基础信息
     */
    @Autowired
    private HtWmsBaseDao htWmsBaseDao;

    /**
     * 物料持久层
     */
    @Autowired
    private McMtlMaterialDao mcMtlMaterialDao;

    /**
     * 物料管控参数(化学品)业务层
     */
    @Autowired
    private McMtmMaterialParamBo mcMtmMaterialParamBo;


    /**
     * 线边领料的物料
     */
    @Autowired
    private HtWmsLnMtlAlyOrderDao htWmsLnMtlAlyOrderDao;

    /**
     * 回温处理
     */
    @Autowired
    private MaterialSerialAndGroupBO materialSerialAndGroupBO;


    /**
     * 物料类型业务
     */
    @Autowired
    private McMtlTypeDao mcMtlTypeDao;

    /**
     * 回温查询
     */
    @Autowired
    private MaterialserialAndGroupDao materialserialAndGroupDao;


    /**
     * 分页查询移料数量
     *
     * @param mpMtlMoveEntity
     * @return
     */
    public int countMpMtlMoveList(MpMtlMoveEntity mpMtlMoveEntity) {
        return mpMtlMoveDao.countMpMtlMoveHtWmsList(mpMtlMoveEntity);
    }

    /**
     * 分页查询移料数据
     *
     * @param mpMtlMoveEntity
     * @return
     */
    public List<MpMtlMoveEntity> findMpMtlMoveList(MpMtlMoveEntity mpMtlMoveEntity) {
        return mpMtlMoveDao.findMpMtlMoveHtWmsList(mpMtlMoveEntity);
    }

    /**
     * 根据id查询移料数据
     *
     * @param id
     * @return
     */
    public MpInvActivityEntity findMpMtlMoveById(String id) {
        // 查询线边仓移料活动数据
        MpInvActivityEntity mpInvActivityEntity = mpInvActivityDao.findMpInvActivityById(id);
        if (null != mpInvActivityEntity) {
            //数据字典转化
            mpInvActivityEntity.setMoveMaterialTypeName(DictBo.getDictLabel(mpInvActivityEntity.getMoveMaterialType(), BizDictType.MOVE_MATERIAL_TYPE,""));
            mpInvActivityEntity.setMoveMaterialSourceName(DictBo.getDictLabel(mpInvActivityEntity.getMoveMaterialSource(), BizDictType.MOVE_MATERIAL_SOURCE,""));
            mpInvActivityEntity.setMoveMaterialTypeReturnName(DictBo.getDictLabel(mpInvActivityEntity.getMoveMaterialSource(), BizDictType.MOVE_MATERIAL_TYPE_RETURN,""));

            // 查询线边仓收料活动明细
            mpInvActivityEntity.setMpMtlMoveList(getMpInvActivityDtlListByInvactivityId(id));
            if(Objects.nonNull(mpInvActivityEntity.getApplicantId())) {
                mpInvActivityEntity.setApplicant(UserBo.getUserNameById(mpInvActivityEntity.getApplicantId()));
            }
        }
        return mpInvActivityEntity;
    }

    /**
     * 根据物料活动id获取活动明细数据
     *
     * @param invactivityId
     * @return
     */
    private List<MpMtlMoveEntity> getMpInvActivityDtlListByInvactivityId(String invactivityId) {
        // 查询线边仓移料活动明细
        List<MpMtlMoveEntity> mpMtlMoveList = mpMtlMoveDao.findMpMtlMoveById(invactivityId);
        if (CollectionUtils.isEmpty(mpMtlMoveList)) {
            return mpMtlMoveList;
        } else {
            for (MpMtlMoveEntity dtlEntity : mpMtlMoveList) {
                dtlEntity.setOriginalLocationKindName(DictBo.getDictLabel(dtlEntity.getOriginalLocationKind(), DictType.MP_INV_MTLLOC_LOCATION_KIND, null));
                dtlEntity.setTargetLocationKindName(DictBo.getDictLabel(dtlEntity.getTargetLocationKind(), DictType.MP_INV_MTLLOC_LOCATION_KIND, null));
                dtlEntity.setMtlKindName(DictBo.getDictLabel(dtlEntity.getMtlKind(), DictType.MC_MTL_MATERIAL_KIND, null));
            }
        }
        // 查询该物料活动下所有物料序列数据
        List<MpInvActivitySnEntity> mpInvActivitySnList = mpInvActivitySnDao.findMpInvActivitySnListByInvactivityId(invactivityId);

        // 查询该物料活动下所有物料序列数据
        List<MpInvActivitySnHtWmsEntity> mpInvActivitySnHtWmsList = mpInvActivitySnHtWmsDao.findMpInvActivitySnnHtWmsListByInvactivityId(invactivityId);


        // 遍历物料活动明细拼接物料活动序列数据
        mpMtlMoveList.forEach(mpMtlMoveEntity -> {
            mpMtlMoveEntity.setMtlKindName(DictBo.getDictLabel(mpMtlMoveEntity.getMtlKind(), DictType.MC_MTL_MATERIAL_KIND, null));

            if (!CollectionUtils.isEmpty(mpInvActivitySnList)) {
                // 把物料活动序列数据根据明细id进行分组
                Map<String, List<MpInvActivitySnEntity>>  mpInvActivitySnMap = mpInvActivitySnList.stream().collect(Collectors.groupingBy(MpInvActivitySnEntity::getInvactivitydtlId));
                mpMtlMoveEntity.setMpInvActivitySnList(mpInvActivitySnMap.get(mpMtlMoveEntity.getOriginalId()));

            }
            if (!CollectionUtils.isEmpty(mpInvActivitySnHtWmsList)) {

                //日期设置
                for (MpInvActivitySnHtWmsEntity mpInvActivitySnHtItem : mpInvActivitySnHtWmsList) {
                    mpInvActivitySnHtItem.setManufactureDateStr(DateUtils.dateToStr(mpInvActivitySnHtItem.getManufactureDate(), DateUtil.YYYY_MM_DD_HH_MM_SS));
                    mpInvActivitySnHtItem.setDvDateStr(DateUtils.dateToStr(mpInvActivitySnHtItem.getDvDate(), DateUtil.YYYY_MM_DD_HH_MM_SS));
                }
                // 把物料活动序列数据根据明细id进行分组
                Map<String, List<MpInvActivitySnHtWmsEntity>> mpInvActivitySnHtWmsMap = mpInvActivitySnHtWmsList.stream().collect(Collectors.groupingBy(MpInvActivitySnHtWmsEntity::getInvactivitydtlId));

                mpMtlMoveEntity.setMpInvActivitySnHtWmsList(mpInvActivitySnHtWmsMap.get(mpMtlMoveEntity.getOriginalId()));
            }

        });
        return mpMtlMoveList;
    }

    /**
     * 线边仓活动记录入库
     *
     * @param mpInvActivityEntity
     */
    @Transactional(rollbackFor = Exception.class, timeout = 1200)
    @LockFunctionNew(key = "MpMtlMoveBo.saveMtlMoveNew")
    public BaseReturn saveMtlMoveNew(String id, MpInvActivityEntity mpInvActivityEntity, String operatorType,String op) {
        BaseReturn result = new BaseReturn(Bool.TRUE.getVal(), BaseErrorCode.SUCCESS);

        // WMS物料条码-插入物料活动明细数据
        if (CollectionUtils.isEmpty(mpInvActivityEntity.getMpInvActivitySnHtWmsList())) {
            result.setSuccess(Bool.FALSE.getVal());
            result.setCode(20001);
            result.setMsg("WMS物料条码不能为空");
            return result;
        }

        //todo A01由于后续是抛出异常的默认成功， 领料申请单完成，当确认时状态为Y
        if (!mpInvActivityEntity.getOrderStatus().equals("Y")&&mpInvActivityEntity.getHtWmsStatus().equals("2")) {
            mpInvActivityEntity.setOrderStatus(YES.getWhether());
        }

        if (StringUtils.isEmpty(id)) {
            // 插入物料活动数据
            mpInvActivityEntity.setVerNo(BaseNum.ZERO.getNum());
            mpInvActivityDao.insertInvActivity(mpInvActivityEntity);
        } else {
            // 当确认时状态为Y
            if (OperatorTypeEnum.SUBMIT.getType().equals(operatorType)) {
                mpInvActivityEntity.setOrderStatus(YES.getWhether());
            }

            // 修改物料活动数据
            mpInvActivityEntity.preUpdate();
            mpInvActivityEntity.setId(id);
            mpInvActivityDao.updateInvActivity(mpInvActivityEntity);
            // 删除物料活动明细数据
            mpInvActivityDtlDao.deleteInvActivityDtlByInvactivityId(id);
            // 删除物料活动序列号数据
            mpInvActivitySnDao.deleteInvActivitySnByInvactivityId(id);

            // WMS物料条码-删除物料活动序列号数据
            mpInvActivitySnHtWmsDao.deleteInvActivitySnHtWmsByInvactivityId(id);
        }
        // 插入物料活动明细数据
        List<MpInvActivityDtlEntity> mpInvActivityDtlList = mpInvActivityEntity.getMpInvActivityDtlList();
        if (CollectionUtils.isNotEmpty(mpInvActivityDtlList)) {
            mpInvActivityDtlDao.insertInvActivityDtl(mpInvActivityDtlList);
        }
        // 插入物料活动明细数据
        log.info("插入物料活动明细数据-getMpInvActivitySnList",mpInvActivityEntity.getMpInvActivitySnList());
        log.info("插入物料活动明细数据-status",CollectionUtils.isNotEmpty(mpInvActivityEntity.getMpInvActivitySnList()));
//        if (CollectionUtils.isNotEmpty(mpInvActivityEntity.getMpInvActivitySnList())) {
//            mpInvActivitySnDao.insertInvActivitySn(mpInvActivityEntity.getMpInvActivitySnList());
//        }

        // WMS物料条码-插入物料活动明细数据
        if (CollectionUtils.isNotEmpty(mpInvActivityEntity.getMpInvActivitySnHtWmsList())) {
            mpInvActivitySnHtWmsDao.insertInvActivitySnHtWms(mpInvActivityEntity.getMpInvActivitySnHtWmsList());
        }


        //op=1 只是生产界面实体
        if(op.equals("1")){
            result.setMsg("车间领料生成创建成功！");//同时WMS线边领料申请生成成功
            return result;
        }



        // 当不为确认入库时则直接返回
//        if (!OperatorTypeEnum.SUBMIT.getType().equals(operatorType)) {}

        /*******按物料条码生成线边仓的工作中心库存*********/
        // 将物料活动信息生成库存实体数据
        List<MpInvMtlGroupEntity> mpInvMtlGroupList = getMpInvMtlGroupEntityHtWmsNew(mpInvActivityEntity);
//        getMpInvMtlGroupEntityNew(mpInvActivityEntity, mpInvMtlGroupList, result);
        if (mpInvMtlGroupList.size()<1) {
            throw new RuntimeException("物料活动信息生成库存实体数据生成失败。");
        }


        // 进行物料信息操作，判断库存数据是否存在
        int size = mpInvMtlGroupList.size();
        List<String> mtlgroupNoList = new ArrayList<>();
        mpInvMtlGroupList.forEach(mpInvMtlGroupEntity -> mtlgroupNoList.add(mpInvMtlGroupEntity.getMtlgroupNo()));

        // 查询已存在的库存
        List<String> mtlgroupNoExistsList = mpInvMtlGroupDao.countMtlGroupByMtlgroupNoList(mtlgroupNoList);
        Map<String, String> mtlgroupNoExistsMap = new HashMap<>(mtlgroupNoExistsList.size());
        mtlgroupNoExistsList.forEach(mtlgroupNo -> mtlgroupNoExistsMap.put(mtlgroupNo, mtlgroupNo));

        // 新库存数据
        List<MpInvMtlGroupEntity> newMpInvMtlGroupList = new ArrayList<>(size);
        // 新库存参数数据
        List<MpInvMtlGroupParamEntity> newMpInvMtlGroupParamList = new ArrayList<>(size);
        // 新库存位置数据
        List<MpInvMtlLocEntity> newMpInvMtlLocList = new ArrayList<>(size);
        // 老库存位置数据
        List<MpInvMtlLocEntity> oldMpInvMtlLocList = new ArrayList<>(size);
        mpInvMtlGroupList.forEach(mpInvMtlGroupEntity -> {

            if (StringUtils.isEmpty(mtlgroupNoExistsMap.get(mpInvMtlGroupEntity.getMtlgroupNo()))) {
                // 新批次信息
                newMpInvMtlGroupList.add(mpInvMtlGroupEntity);
                // 新批次参数信息
                newMpInvMtlGroupParamList.addAll(mpInvMtlGroupEntity.getMpInvMtlGroupParamEntityList());
            }




            List<MpInvMtlLocEntity> mpInvMtlLocList = mpInvMtlGroupEntity.getMpInvMtlLocList();
            mpInvMtlLocList.forEach(locEntity -> {
                // 判断批次位置数据是否存在
                if (CollectionUtils.isEmpty(mpInvMtlLocDao.findMpInvMtlLocExists(locEntity.getMtlgroupNo(), locEntity.getLocationId()))) {
                    newMpInvMtlLocList.add(locEntity);
                } else {
                    oldMpInvMtlLocList.add(locEntity);
                }
            });





        });
        Date now = new Date();
        // 新增库存数据
        if (CollectionUtils.isNotEmpty(newMpInvMtlGroupList)) {
            // 新增时间和修改时间设置为当前系统时间 lzk 2020/7/10
            for (MpInvMtlGroupEntity mpInvMtlGroupEntity : newMpInvMtlGroupList) {
                mpInvMtlGroupEntity.setCreateDate(now);
                mpInvMtlGroupEntity.setUpdateDate(now);

            }
            mpInvMtlGroupDao.batchInsertMpInvMtlGroup(newMpInvMtlGroupList);
        }
        // 新增库存参数数据
        if (CollectionUtils.isNotEmpty(newMpInvMtlGroupParamList)) {
            for (MpInvMtlGroupParamEntity mpInvMtlGroupParamEntity : newMpInvMtlGroupParamList) {
                mpInvMtlGroupParamEntity.setCreateDate(now);
                mpInvMtlGroupParamEntity.setUpdateDate(now);
            }
            mpInvMtlGroupParamDao.insertMpInvMtlGroupParam(newMpInvMtlGroupParamList);
        }
        // 新增库存位置数据
        if (CollectionUtils.isNotEmpty(newMpInvMtlLocList)) {
            mpInvMtlLocDao.batchInsertMpInvMtlLoc(newMpInvMtlLocList);
        }
        // 修改库存位置数据
        if (CollectionUtils.isNotEmpty(oldMpInvMtlLocList)) {
            mpInvMtlLocDao.batchUpdateMpInvMtlLocByLocation(oldMpInvMtlLocList);
        }



        /*************************ezio 2025-06-03 立即回温处理-开始*************************/
        // 回温的List
//        List<String> wetherList = new ArrayList<>();
        //回温操作列表
        List<MaterialSerialAndGroupInfoEntity> operationEntities = new ArrayList<>();
        // 获取当前日期和时间
        LocalDateTime localDate = LocalDateTime.now();
        Date currentDate = new Date();
        // 格式化输出
//        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//        String formattedNow = localDate.format(formatter);

        // 回温物料的分页查询
        MaterialSerialAndGroupQueryEntity queryEntity = new MaterialSerialAndGroupQueryEntity();
        queryEntity.setMaterialGroupNos(mtlgroupNoList);
        RowBounds rowBounds = new RowBounds(0, 200);
        List<MaterialSerialAndGroupInfoEntity> serialAndGroupInfoEntities = materialserialAndGroupDao.listByCondition(queryEntity,rowBounds);



        serialAndGroupInfoEntities.forEach(  serialAndGroupInfo -> {

                    // 获取数据字典配置的工序
                    Map<String, String> mtlTypeDictMap = DictBo.getDictMap("BackWhetherPromptlyByMtlTypeInWork");
                    if(mtlTypeDictMap!=null){

                        //物料档案信息获取
                        McMtlMaterialEntity mcMtlMaterial = mcMtlMaterialDao.queryMcMtlMaterialById(serialAndGroupInfo.getMaterialId());
                        McMtlTypeEntity mcMtlTypeEntity = mcMtlTypeDao.findMtlTypeByTypeId(mcMtlMaterial.getMtltypeId());

                        if(mtlTypeDictMap.get(mcMtlTypeEntity.getMtlType())!=null&&"Rewarming".equals(serialAndGroupInfo.getMaterialKindKey())&&"UnThaw".equals(serialAndGroupInfo.getRewarmingStateKey())){

                            //回温实体
                             MaterialSerialAndGroupInfoEntity materialSerialAndGroupInfo = new MaterialSerialAndGroupInfoEntity();

                             BeanUtil.copyProperties(serialAndGroupInfo, materialSerialAndGroupInfo);

                            // 物料种类key==>物料种类名称
                            materialSerialAndGroupInfo.setMaterialKindName(MaterialAllKindEnum.getMaterialKindValue(materialSerialAndGroupInfo.getMaterialKindKey()));
                            // 时效状态key==>时效状态名称
                            materialSerialAndGroupInfo.setRewarmingStateName(MaterialRewarmingStateEnum.getMaterialStateValue(materialSerialAndGroupInfo.getRewarmingStateKey()));
                            // param子对象单位key ==> 单位名称  回温次数设置到父对象
                            List<MaterialSerialOrGroupParamEntity> paramEntities = materialSerialAndGroupInfo.getParamEntities();
                            for (MaterialSerialOrGroupParamEntity paramEntity : paramEntities) {
                                paramEntity.setUnitName(ParamUnitEnum.getParamUnitValue(paramEntity.getUnitKey()));
                                if ("ThawPDU".equals(paramEntity.getControlType())) {
                                    materialSerialAndGroupInfo.setRewarmingCurrentNumber(paramEntity.getExecuteNumber());
                                }
                            }

                             materialSerialAndGroupInfo.setUpdateDate(currentDate);

                            //参数列表
                            List<MaterialSerialOrGroupParamEntity> materialSerialOrGroupParamList = materialSerialAndGroupInfo.getParamEntities();

                            for (MaterialSerialOrGroupParamEntity materialSerialOrGroupParam : materialSerialOrGroupParamList) {
                                //列表查询的补充修改
                                materialSerialOrGroupParam.setUnitName(ParamUnitEnum.getParamUnitValue(materialSerialOrGroupParam.getUnitKey()));
                                if ("ThawPDU".equals(materialSerialOrGroupParam.getControlType())) {
                                    materialSerialAndGroupInfo.setRewarmingCurrentNumber(materialSerialOrGroupParam.getExecuteNumber());
                                }


                                //模仿前端回温操作，结束时间判断  ValidDU=有效期，ThawPDU=回温时间，ThawVDU=回温后日期
                                if(materialSerialOrGroupParam.getControlType().equals("ThawPDU")){
                                    //回温开始时间
                                    materialSerialAndGroupInfo.setStartTime(currentDate);
                                    //回温时间
                                    Date endTime = MesDateUtils.addDate(currentDate, getDateAmount(materialSerialOrGroupParam.getUnitKey()), materialSerialOrGroupParam.getLimitNumber().intValue());
                                    materialSerialAndGroupInfo.setEndTime(endTime);

                                }
                                else if(materialSerialOrGroupParam.getControlType().equals("ValidDU")){

                                    //todo startTime不是当前时间
                                    Date vduEndTime = MesDateUtils.addDate(materialSerialOrGroupParam.getStartTime(), getDateAmount(materialSerialOrGroupParam.getUnitKey()), materialSerialOrGroupParam.getLimitNumber().intValue());
                                    //回温有效期
                                    materialSerialAndGroupInfo.setThawVduEndTime(vduEndTime);
                                }
                            };
//                            if (CollectionUtils.isNotEmpty(materialSerialOrGroupParamList)) {
//                                materialSerialAndGroupInfo.setParamEntities(materialSerialOrGroupParamList);
//                            }

                            operationEntities.add(materialSerialAndGroupInfo);
                        }


                    }




        });

        //按数据字典判断是否需要回温
        // 回温操作(修改时效状态+可用状态)
        if (CollectionUtils.isNotEmpty(operationEntities)) {

            materialSerialAndGroupBO.materialRewarm(operationEntities);
        }
        /*************************ezio 2025-06-03 立即回温处理-结束*************************/


        /*******按物料条码生成线边仓的工作中心库存-结束*********/





        //WMS生成调拨申请单
        //推送给WMS的调拨申请单
        HtWmsMtlOutRequestDTO htWmsMtlOutRequestDTO = convertMtlMoveRequest(mpInvActivityEntity);
        BaseReturn<HtApiResponse>  baseReturnRes = htWmsApiBo.htWmsMtlOutApi(htWmsMtlOutRequestDTO);
        if(!baseReturnRes.isSuccess()){
            throw new RuntimeException("接口异常："+baseReturnRes.getMsg());
        }

        //A02领料申请单完成，当确认时状态为Y;A01默认已处理状态；
//        if (!mpInvActivityEntity.getOrderStatus().equals("Y")&&mpInvActivityEntity.getHtWmsStatus().equals("2")) {
//            String updateBy = UserInfo.getUserInfoNew() == null ? "" : UserInfo.getUserInfoNew().getUserId();
//            mpInvActivityDao.updateOrderStatusById("Y",updateBy,mpInvActivityEntity.getId(),null);
//        }




        result.setMsg("车间领料生成创建成功！");//同时WMS线边领料申请生成成功
        return result;




    }



    /**
     * 车间退料
     *
     * @param mpInvActivityEntity
     */
    @Transactional(rollbackFor = Exception.class, timeout = 1200)
    @LockFunctionNew(key = "MpMtlMoveBo.saveMtlMoveReturn")
    public BaseReturn saveMtlMoveReturn(String id, MpInvActivityEntity mpInvActivityEntity, String operatorType,String op){
        BaseReturn result = new BaseReturn(Bool.TRUE.getVal(), BaseErrorCode.SUCCESS);

        // WMS物料条码-插入物料活动明细数据
        if (CollectionUtils.isEmpty(mpInvActivityEntity.getMpInvActivitySnHtWmsList())) {
            result.setSuccess(Bool.FALSE.getVal());
            result.setCode(20001);
            result.setMsg("WMS物料条码不能为空");
            return result;
        }
        // 插入物料活动明细数据
        List<MpInvActivityDtlEntity> mpInvActivityDtlList = mpInvActivityEntity.getMpInvActivityDtlList();

        //卡控判断，物料在设备上料中，不可退料
        List<String> mtlgroupNoMesList = new ArrayList<>();
        mpInvActivityDtlList.forEach(mpInvActivityDtlItem -> {

            if(mpInvActivityDtlItem.getMovelocType().equals("From")){
                if(mpInvActivityDtlItem.getMaterialBarcodeOrigin()!=null&&!mpInvActivityDtlItem.getMaterialBarcodeOrigin().isEmpty()){
                    mtlgroupNoMesList.add(mpInvActivityDtlItem.getMaterialBarcodeOrigin());
                }
            }

        });
        if(CollectionUtils.isNotEmpty(mtlgroupNoMesList)){
            HtEqpMtlDTO htEqpMtlDTO = htWmsBaseDao.findEqpMtlByMtlgroupNo(mtlgroupNoMesList);
            if(htEqpMtlDTO!=null){
                result.setSuccess(Bool.FALSE.getVal());
                result.setCode(20001);
                result.setMsg("车间退料失败，"+htEqpMtlDTO.getMaterialSn()+"还在设备"+htEqpMtlDTO.getEqpCode()+"上。");
                return result;
//                throw new Exception("车间退料失败，"+htEqpMtlDTO.getMaterialSn()+"还在设备"+htEqpMtlDTO.getEqpCode()+"上。");
            }
        }




        //todo A01由于后续是抛出异常的默认成功， 领料申请单完成，当确认时状态为Y
        if (!mpInvActivityEntity.getOrderStatus().equals("Y")&&mpInvActivityEntity.getHtWmsStatus().equals("2")) {
            mpInvActivityEntity.setOrderStatus(YES.getWhether());
        }

        if (StringUtils.isEmpty(id)) {
            // 插入物料活动数据
            mpInvActivityEntity.setVerNo(BaseNum.ZERO.getNum());
            mpInvActivityDao.insertInvActivity(mpInvActivityEntity);
        } else {
            // 当确认时状态为Y
            if (OperatorTypeEnum.SUBMIT.getType().equals(operatorType)) {
                mpInvActivityEntity.setOrderStatus(YES.getWhether());
            }

            // 修改物料活动数据
            mpInvActivityEntity.preUpdate();
            mpInvActivityEntity.setId(id);
            mpInvActivityDao.updateInvActivity(mpInvActivityEntity);
            // 删除物料活动明细数据
            mpInvActivityDtlDao.deleteInvActivityDtlByInvactivityId(id);
            // 删除物料活动序列号数据
            mpInvActivitySnDao.deleteInvActivitySnByInvactivityId(id);

            // WMS物料条码-删除物料活动序列号数据
            mpInvActivitySnHtWmsDao.deleteInvActivitySnHtWmsByInvactivityId(id);
        }

        if (CollectionUtils.isNotEmpty(mpInvActivityDtlList)) {
            mpInvActivityDtlDao.insertInvActivityDtl(mpInvActivityDtlList);
        }
        // 插入物料活动明细数据
        log.info("插入物料活动明细数据-getMpInvActivitySnList",mpInvActivityEntity.getMpInvActivitySnList());
        log.info("插入物料活动明细数据-status",CollectionUtils.isNotEmpty(mpInvActivityEntity.getMpInvActivitySnList()));
//        if (CollectionUtils.isNotEmpty(mpInvActivityEntity.getMpInvActivitySnList())) {
//            mpInvActivitySnDao.insertInvActivitySn(mpInvActivityEntity.getMpInvActivitySnList());
//        }

        // WMS物料条码-插入物料活动明细数据
        if (CollectionUtils.isNotEmpty(mpInvActivityEntity.getMpInvActivitySnHtWmsList())) {
            mpInvActivitySnHtWmsDao.insertInvActivitySnHtWms(mpInvActivityEntity.getMpInvActivitySnHtWmsList());
        }


        //op=1 只是生产界面实体
        if(op.equals("1")){
            result.setMsg("车间退料生成创建成功！");//同时WMS线边领料申请生成成功
            return result;
        }



        // 当不为确认入库时则直接返回
//        if (!OperatorTypeEnum.SUBMIT.getType().equals(operatorType)) {}

        /*******按物料条码生成线边仓的工作中心库存*********/
        // 将物料活动信息生成库存实体数据
        List<MpInvMtlGroupEntity> mpInvMtlGroupList = getMpInvMtlGroupEntityHtWmsNew(mpInvActivityEntity);
//        getMpInvMtlGroupEntityNew(mpInvActivityEntity, mpInvMtlGroupList, result);
        if (mpInvMtlGroupList.size()<1) {
            throw new RuntimeException("车间退料-物料活动信息生成库存实体数据生成失败。");
        }


        // 进行物料信息操作，判断库存数据是否存在
        int size = mpInvMtlGroupList.size();
        List<String> mtlgroupNoList = new ArrayList<>();
        mpInvMtlGroupList.forEach(mpInvMtlGroupEntity -> mtlgroupNoList.add(mpInvMtlGroupEntity.getMtlgroupNo()));

        // 查询已存在的库存
        List<String> mtlgroupNoExistsList = mpInvMtlGroupDao.countMtlGroupByMtlgroupNoList(mtlgroupNoList);
        Map<String, String> mtlgroupNoExistsMap = new HashMap<>(mtlgroupNoExistsList.size());
        mtlgroupNoExistsList.forEach(mtlgroupNo -> mtlgroupNoExistsMap.put(mtlgroupNo, mtlgroupNo));

        // 新库存数据
        List<MpInvMtlGroupEntity> newMpInvMtlGroupList = new ArrayList<>(size);
        // 新库存参数数据
        List<MpInvMtlGroupParamEntity> newMpInvMtlGroupParamList = new ArrayList<>(size);
        // 新库存位置数据
//        List<MpInvMtlLocEntity> newMpInvMtlLocList = new ArrayList<>(size);
        // 老库存位置数据
        List<MpInvMtlLocEntity> oldMpInvMtlLocList = new ArrayList<>(size);


        //已处理的物料条码，父条码不处理，当前没有这类异常
        List<String> mtlgroupNoListOlder = new ArrayList<>();
        mpInvMtlGroupList.forEach(mpInvMtlGroupEntity -> {

            if (StringUtils.isEmpty(mtlgroupNoExistsMap.get(mpInvMtlGroupEntity.getMtlgroupNo()))) {
                // 新批次信息
                newMpInvMtlGroupList.add(mpInvMtlGroupEntity);
                // 新批次参数信息
                newMpInvMtlGroupParamList.addAll(mpInvMtlGroupEntity.getMpInvMtlGroupParamEntityList());
            }




            List<MpInvMtlLocEntity> mpInvMtlLocList = mpInvMtlGroupEntity.getMpInvMtlLocList();
            mpInvMtlLocList.forEach(locEntity -> {
                // 判断批次位置数据是否存在
                if (CollectionUtils.isEmpty(mpInvMtlLocDao.findMpInvMtlLocExists(locEntity.getMtlgroupNo(), locEntity.getLocationId()))) {

                    //车间退料到WMS的线边仓
                    //                    newMpInvMtlLocList.add(locEntity);
                } else {
                    oldMpInvMtlLocList.add(locEntity);
                    mtlgroupNoListOlder.add(locEntity.getMtlgroupNo());
                }
            });





        });
        Date now = new Date();
        // 新增库存数据
        if (CollectionUtils.isNotEmpty(newMpInvMtlGroupList)) {
            // 新增时间和修改时间设置为当前系统时间 lzk 2020/7/10
            for (MpInvMtlGroupEntity mpInvMtlGroupEntity : newMpInvMtlGroupList) {
                mpInvMtlGroupEntity.setCreateDate(now);
                mpInvMtlGroupEntity.setUpdateDate(now);

            }
            mpInvMtlGroupDao.batchInsertMpInvMtlGroup(newMpInvMtlGroupList);
        }
        // 新增库存参数数据
        if (CollectionUtils.isNotEmpty(newMpInvMtlGroupParamList)) {
            for (MpInvMtlGroupParamEntity mpInvMtlGroupParamEntity : newMpInvMtlGroupParamList) {
                mpInvMtlGroupParamEntity.setCreateDate(now);
                mpInvMtlGroupParamEntity.setUpdateDate(now);
            }
            mpInvMtlGroupParamDao.insertMpInvMtlGroupParam(newMpInvMtlGroupParamList);
        }
        // 新增库存位置数据
//        if (CollectionUtils.isNotEmpty(newMpInvMtlLocList)) {
//            mpInvMtlLocDao.batchInsertMpInvMtlLoc(newMpInvMtlLocList);
//        }

        // 修改库存位置数据
        if (CollectionUtils.isNotEmpty(oldMpInvMtlLocList)) {
            mpInvMtlLocDao.batchUpdateMpInvMtlLocReturnByLocation(oldMpInvMtlLocList);
        }


        //拆箱后父物料条码，数量清空为0
        List<MpInvMtlLocEntity> mpInvMtlLocListParent = new ArrayList<>();

        mpInvActivityDtlList.forEach(mpInvActivityDtlItem -> {

            if(mpInvActivityDtlItem.getMovelocType().equals("From")&&(!mtlgroupNoListOlder.contains(mpInvActivityDtlItem.getMaterialBarcode()))){
                MpInvMtlLocEntity mpInvMtlLocEntityItem = new MpInvMtlLocEntity();

                //物料条码不同
                if(!mpInvActivityDtlItem.getMaterialBarcodeOrigin().equals(mpInvActivityDtlItem.getBatchNo())){
                    mpInvMtlLocEntityItem.setMtlgroupNo(mpInvActivityDtlItem.getMaterialBarcodeOrigin());
                    mpInvMtlLocEntityItem.setMtlQty(mpInvActivityDtlItem.getMaterialQtyOrigin().negate());
                    mpInvMtlLocEntityItem.setMtlSpuqty((long) 0);
                    mpInvMtlLocEntityItem.setLocationId(mpInvActivityDtlItem.getLocationId());
                    mpInvMtlLocListParent.add(mpInvMtlLocEntityItem);
                }
            }


        });

        if (CollectionUtils.isNotEmpty(mpInvMtlLocListParent)) {
            mpInvMtlLocDao.batchUpdateMpInvMtlLocReturnByLocation(mpInvMtlLocListParent);
        }








        /*******按物料条码生成线边仓的工作中心库存-结束*********/






        //推送给WMS的车间退料的红字材料出库单
        HtWmsMtlOutRequestDTO htWmsMtlOutRequestDTO = convertMtlMoveReturnRequest(mpInvActivityEntity);
        BaseReturn<HtWmsResponseDTO>  baseReturnRes = htWmsApiBo.htWmsMtlOutReturnApi(htWmsMtlOutRequestDTO);
        if(!baseReturnRes.isSuccess()){
            throw new RuntimeException("接口异常："+baseReturnRes.getMsg());
        }






        result.setMsg("车间退料生成创建成功！");//同时WMS线边领料申请生成成功
        return result;




    }


    /**
     * 根据编号+物料批次号查询工治具信息
     *
     * @param sn         工治具编号、化学品编号
     * @param mtlgroupNo 物料批次号
     * @param mtlKind    工治具、化学品
     * @return
     */
    public MpInvActivitySnEntity findSerialmtlByMaterialSnAndMtlgroupNo(String sn, String mtlgroupNo, String locationId, String mtlKind) {
        MpInvActivitySnEntity mpInvActivitySnEntity = new MpInvActivitySnEntity();

        McMtmSerialmtlEntity mcMtmSerialmtlEntity = mcMtmSerialmtlBo.findSerialmtlByMaterialSnAndGroupNo(sn, mtlgroupNo, locationId);
        if (null != mcMtmSerialmtlEntity) {
            mpInvActivitySnEntity.setMaterialSn(mcMtmSerialmtlEntity.getMaterialSn());
            mpInvActivitySnEntity.setMaterialQty(mcMtmSerialmtlEntity.getMaterialQty());
            mpInvActivitySnEntity.setActiveFlag(mcMtmSerialmtlEntity.getActiveFlag());
        }

        return mpInvActivitySnEntity;
    }

    /**
     * 根据物料收料活动数据生成物料库存数据
     *
     * @param mpInvActivityEntity
     * @return
     */
    private void getMpInvMtlGroupEntityNew(MpInvActivityEntity mpInvActivityEntity, List<MpInvMtlGroupEntity> mpInvMtlGroupList, BaseReturn baseReturn) {
        List<MpInvActivityDtlEntity> mpInvActivityDtlList = mpInvActivityEntity.getMpInvActivityDtlList();
        String fromLocationId = null;
        Map<String, MpInvMtlGroupEntity> groupMap = new HashMap<>(mpInvActivityDtlList.size());
        Map<String, MpInvMtlLocEntity> locMap = new HashMap<>(mpInvActivityDtlList.size());
        //物料批次对应的物料条码
        List<MpInvActivitySnHtWmsEntity>  mpInvActivitySnHtWmsEntityList =  mpInvActivityEntity.getMpInvActivitySnHtWmsList();
        for (MpInvActivityDtlEntity dtlEntity : mpInvActivityDtlList) {
            if (MovelocTypeEnum.FROM.getCode().equals(dtlEntity.getMovelocType())) {
                fromLocationId = dtlEntity.getLocationId();
                continue;
            }

            if (dtlEntity.getMtlQty().compareTo(BigDecimal.valueOf(0))< 0) {
                //2024-12-21 生产退还导致工作中心为负数，默认处理为0
                if(!Objects.equals(mpInvActivityEntity.getMoveMaterialType(), "return")||!Objects.equals(mpInvActivityEntity.getMoveMaterialReturnAbove(), "Y")){
                    baseReturn.setSuccess(false);
                    baseReturn.setCode(20001);
                    baseReturn.setMsg("不是生产退还，不能是负数");
                    return;
                }
            }



            for (MpInvActivitySnHtWmsEntity snHtWmsItem : mpInvActivitySnHtWmsEntityList) {



                //物料批次下对应的物料条码
                if(Objects.equals(snHtWmsItem.getInvactivitydtlId(), dtlEntity.getId())){








                    MpInvMtlLocEntity oldMpInvMtlLocEntity = new MpInvMtlLocEntity();
                    //补充历史库存信息
                    oldMpInvMtlLocEntity.setMtlgroupKind("Mlot");//Mlot
                    oldMpInvMtlLocEntity.setMtlgroupNo(snHtWmsItem.getMaterialBarcode());
                    oldMpInvMtlLocEntity.setMtlState("Normal");
                    //todo 库存物料组ID当前没有值 ，需要补充
                    oldMpInvMtlLocEntity.setMtlgroupId(dtlEntity.getMtlgroupId());//库存物料组ID

                    oldMpInvMtlLocEntity.setLocationKind(dtlEntity.getLocationKind());//MWC
                    // 收料位置类别默认工作中心
//                    oldMpInvMtlLocEntity.setLocationKind(LocationKindEnum.MWC.getCode());//WINV=线边仓
                    oldMpInvMtlLocEntity.setLocationId(dtlEntity.getLocationId());
                    oldMpInvMtlLocEntity.setLocationCode(dtlEntity.getLocationCode());
                    oldMpInvMtlLocEntity.setLocationName(dtlEntity.getLocationName());
                    oldMpInvMtlLocEntity.setProdorgId(mpInvActivityEntity.getProdorgId());//车间

                    //物料编码查询物料ID
                    HtWmsMaterialInfoEntity htWmsMaterialInfoEntity = htWmsBaseDao.findMtlByMtlCode(dtlEntity.getMaterialCode());

                    oldMpInvMtlLocEntity.setMaterialId(htWmsMaterialInfoEntity.getId());
                    oldMpInvMtlLocEntity.setMaterialCode(htWmsMaterialInfoEntity.getMaterialCode());
                    oldMpInvMtlLocEntity.setMaterialName(htWmsMaterialInfoEntity.getMaterialName());
                    oldMpInvMtlLocEntity.setMaterialDesc(htWmsMaterialInfoEntity.getMaterialDesc());
                    oldMpInvMtlLocEntity.setMaterialVer(htWmsMaterialInfoEntity.getRevision());
                    oldMpInvMtlLocEntity.setSerializedFlag("N");//实物管理
                    oldMpInvMtlLocEntity.setMtlUom(htWmsMaterialInfoEntity.getMtlUom());//计量单位ID
                    oldMpInvMtlLocEntity.setMtlUomname(dtlEntity.getMtlUomname());
                    oldMpInvMtlLocEntity.setMtlKind("RawMaterial");
                    // 领用机台
                    oldMpInvMtlLocEntity.setClaimEqpId(mpInvActivityEntity.getClaimEqpId());
                    oldMpInvMtlLocEntity.setClaimEqpCode(mpInvActivityEntity.getClaimEqpCode());
                    oldMpInvMtlLocEntity.setClaimEqpName(mpInvActivityEntity.getClaimEqpName());

                    //ezio 2025-04-21 物料条码的数量
                    oldMpInvMtlLocEntity.setMtlQty(snHtWmsItem.getMaterialQty());
                    //todo 原是物料条码数量，当前用作了物料条码包含数量的库存
                    oldMpInvMtlLocEntity.setMtlSpuqty(Long.valueOf(0));
                    MpInvMtlGroupEntity oldMpInvMtlGroupEntity;

                    //ezio 2025-04-21 使用物料条码
                    oldMpInvMtlGroupEntity = groupMap.get(snHtWmsItem.getMaterialBarcode());

                    oldMpInvMtlGroupEntity.getMpInvMtlLocList().add(oldMpInvMtlLocEntity);

                    // 新库存信息
                    MpInvMtlGroupEntity newMpInvMtlGroupEntity = new MpInvMtlGroupEntity();
                    BeanUtils.copyProperties(oldMpInvMtlGroupEntity, newMpInvMtlGroupEntity);

                    newMpInvMtlGroupEntity = groupMap.get(snHtWmsItem.getMaterialBarcode());
                    newMpInvMtlGroupEntity.getMpInvMtlLocList().add(oldMpInvMtlLocEntity);

                    newMpInvMtlGroupEntity.preInsert();
                    // 获取原库存位置
                    MpInvMtlLocEntity newMpInvMtlLocEntity;
                    // 如果已存在相同位置的批次，则直接汇总
                    if (null != locMap.get(snHtWmsItem.getMaterialBarcode() + dtlEntity.getLocationId())) {
                        newMpInvMtlLocEntity = locMap.get(snHtWmsItem.getMaterialBarcode() + dtlEntity.getLocationId());
                       //物料条码唯一性一般执行不到
                        newMpInvMtlLocEntity.setMtlQty(newMpInvMtlLocEntity.getMtlQty().add(null != snHtWmsItem.getMaterialQty() ? snHtWmsItem.getMaterialQty() : BigDecimal.ZERO));
                        newMpInvMtlLocEntity.setMtlSpuqty(Long.valueOf(0));
                        continue;
                    } else {
                        newMpInvMtlLocEntity = new MpInvMtlLocEntity();
                    }
                    BeanUtils.copyProperties(oldMpInvMtlLocEntity, newMpInvMtlLocEntity);
                    newMpInvMtlLocEntity.preInsert();
                    // 分批情况
//                    if (YES.getWhether().equals(dtlEntity.getLotcontrolledFlag()) && dtlEntity.getOldQty().compareTo(dtlEntity.getMtlQty()) > 0) {
//                        SerialResultEntity serialResult = findRuleAndCreateNo(oldMpInvMtlGroupEntity.getMaterialCode(), oldMpInvMtlGroupEntity.getOrigingroupNo());
//                        if (serialResult.getSerialFlag()) {
//                            newMpInvMtlGroupEntity.setMtlgroupNo(serialResult.getSerialNo());
//                            newMpInvMtlGroupEntity.setParentgroupId(oldMpInvMtlGroupEntity.getId());
//                            oldMpInvMtlGroupEntity.setParentgroupNo(oldMpInvMtlGroupEntity.getMtlgroupNo());
//                            dtlEntity.setBatchNo(newMpInvMtlGroupEntity.getMtlgroupNo());
//                        } else {
//                            baseReturn.error(RESTART_BATCH);
//                            return;
//                        }
//                        newMpInvMtlLocEntity.setMtlgroupId(newMpInvMtlGroupEntity.getId());
//                        newMpInvMtlLocEntity.setMtlgroupNo(newMpInvMtlGroupEntity.getMtlgroupNo());
//                    }
                    // 添加新库存位置
                    newMpInvMtlLocEntity.setLocationKind(dtlEntity.getLocationKind());
                    newMpInvMtlLocEntity.setLocationId(dtlEntity.getLocationId());
                    newMpInvMtlLocEntity.setLocationCode(dtlEntity.getLocationCode());
                    newMpInvMtlLocEntity.setLocationName(dtlEntity.getLocationName());
                    // 领用机台
                    newMpInvMtlLocEntity.setClaimEqpId(dtlEntity.getClaimEqpId());
                    newMpInvMtlLocEntity.setClaimEqpCode(dtlEntity.getClaimEqpCode());
                    newMpInvMtlLocEntity.setClaimEqpName(dtlEntity.getClaimEqpName());
                    // todo 关注变化
                    //  添加新库存数量
                    newMpInvMtlLocEntity.setMtlgroupId(newMpInvMtlGroupEntity.getId());
//            newMpInvMtlLocEntity.setMtlgroupNo(newMpInvMtlGroupEntity.getMtlgroupNo());
                    newMpInvMtlLocEntity.setMtlQty(null != dtlEntity.getMtlQty() ? dtlEntity.getMtlQty() : BigDecimal.ZERO);
                    newMpInvMtlLocEntity.setMtlSpuqty(CollectionUtils.isNotEmpty(dtlEntity.getMpInvActivitySnList()) ? Integer.toUnsignedLong(dtlEntity.getMpInvActivitySnList().size()) : 0);
                    newMpInvMtlGroupEntity.setMpInvMtlLocList(new ArrayList<>(1));
                    newMpInvMtlGroupEntity.getMpInvMtlLocList().add(newMpInvMtlLocEntity);
                    locMap.put(newMpInvMtlLocEntity.getMtlgroupNo() + newMpInvMtlLocEntity.getLocationId(), newMpInvMtlLocEntity);
                    /**
                     * edit by gel 2020/07/02
                     * 获取原参数List赋给新参数List
                     */
                    List<MpInvMtlGroupParamEntity> oldGroupParamEntityList = mpInvMtlGroupParamDao.findMtlGroupParamById(oldMpInvMtlGroupEntity.getId());
                    List<MpInvMtlGroupParamEntity> newGroupParmEntityList = new ArrayList<>();
                    if (CollectionUtils.isNotEmpty(oldGroupParamEntityList)) {
                        for (MpInvMtlGroupParamEntity groupParamEntity : oldGroupParamEntityList) {
                            groupParamEntity.setParentId(newMpInvMtlGroupEntity.getId());
                            groupParamEntity.preInsert();
                            newGroupParmEntityList.add(groupParamEntity);
                        }
                    }
                    if (CollectionUtils.isNotEmpty(newGroupParmEntityList)) {
                        newMpInvMtlGroupEntity.setMpInvMtlGroupParamEntityList(newGroupParmEntityList);
                    }
                    mpInvMtlGroupList.add(newMpInvMtlGroupEntity);

                }





            }



        }


    }


    /**
     * eizo 2025-04-21 根据物料收料活动数据生成物料库存数据实体类
     *
     * @param mpInvActivityEntity 物料活动数据
     * @return 返回物料库存数据
     */
    private List<MpInvMtlGroupEntity> getMpInvMtlGroupEntityHtWms(MpInvActivityEntity mpInvActivityEntity) {
        List<MpInvMtlGroupEntity> mpInvMtlGroupList = new ArrayList<>();
        List<MpInvActivityDtlEntity> mpInvActivityDtlList = mpInvActivityEntity.getMpInvActivityDtlList();

        //物料批次对应的物料条码
        List<MpInvActivitySnHtWmsEntity>  mpInvActivitySnHtWmsEntityList =  mpInvActivityEntity.getMpInvActivitySnHtWmsList();
        String fromLocationId = null;
        for (MpInvActivityDtlEntity mpInvActivityDtlEntityOlder : mpInvActivityDtlList) {
            if (MovelocTypeEnum.FROM.getCode().equals(mpInvActivityDtlEntityOlder.getMovelocType())) {
                fromLocationId = mpInvActivityDtlEntityOlder.getLocationId();
                continue;
            }
            for (MpInvActivitySnHtWmsEntity mpInvActivitySnHtWmsEntity : mpInvActivitySnHtWmsEntityList) {
                MpInvActivityDtlEntity mpInvActivityDtlEntity = new MpInvActivityDtlEntity();
                BeanUtils.copyProperties(mpInvActivityDtlEntityOlder,mpInvActivityDtlEntity);
                //物料批次下对应的物料条码
                if (Objects.equals(mpInvActivitySnHtWmsEntity.getMaterialCode(), mpInvActivityDtlEntity.getMaterialCode())) {

                    //eizo 2025-04-21 更新唯一性批号和条码数量，条码和数量进行调整
                    mpInvActivityDtlEntity.setBatchNo(mpInvActivitySnHtWmsEntity.getMaterialBarcode());
                    mpInvActivityDtlEntity.setMtlQty(mpInvActivitySnHtWmsEntity.getMaterialQty());
                    //生产日期
                    mpInvActivityDtlEntity.setManufactureDate(mpInvActivitySnHtWmsEntity.getManufactureDate());
                    //失效日期-生产日期
                    // 解析字符串为LocalDate对象
                    LocalDate date1 = LocalDate.parse(DateUtils.dateToStr(mpInvActivitySnHtWmsEntity.getManufactureDate(), DateConstant.FORMAT_YYYY_MM_DD));
                    LocalDate date2 = LocalDate.parse(DateUtils.dateToStr(mpInvActivitySnHtWmsEntity.getDvDate(), DateConstant.FORMAT_YYYY_MM_DD));

                    // 使用ChronoUnit计算天数差
                    long daysBetween = ChronoUnit.DAYS.between(date1, date2);
                    BigDecimal validityPeriod = BigDecimal.valueOf(daysBetween);
                    mpInvActivityDtlEntity.setValidityPeriod(validityPeriod);
                    mpInvActivityDtlEntity.setValidityUnit("D");
                    //eizo 2025-04-21 物料编码查询物料ID
                    HtWmsMaterialInfoEntity htWmsMaterialInfoEntity = htWmsBaseDao.findMtlByMtlCode(mpInvActivityDtlEntity.getMaterialCode());
                    mpInvActivityDtlEntity.setMaterialId(htWmsMaterialInfoEntity.getId());
                    mpInvActivityDtlEntity.setMaterialVer(htWmsMaterialInfoEntity.getRevision());
                    mpInvActivityDtlEntity.setMtlKind(htWmsMaterialInfoEntity.getMtlKind());
                    mpInvActivityDtlEntity.setMtlUom(htWmsMaterialInfoEntity.getMtlUom());


                    //之前记录了物料条码的产品数量，而且也不启用原序列号功能
                    mpInvActivityDtlEntity.setMtlSpuqty(Long.valueOf(0));



                    MpInvMtlGroupEntity mpInvMtlGroupEntity = new MpInvMtlGroupEntity(new ArrayList<>(), new ArrayList<>());
                    // 物料库存类别，默认物料批次
                    mpInvMtlGroupEntity.setMtlgroupKind(MtlGroupKind.MLOT.getCode());
                    mpInvMtlGroupEntity.setMtlgroupNo(mpInvActivityDtlEntity.getBatchNo());
                    mpInvMtlGroupEntity.setMaterialId(mpInvActivityDtlEntity.getMaterialId());
                    mpInvMtlGroupEntity.setMaterialCode(mpInvActivityDtlEntity.getMaterialCode());
                    mpInvMtlGroupEntity.setMaterialName(mpInvActivityDtlEntity.getMaterialName());
                    mpInvMtlGroupEntity.setMaterialDesc(mpInvActivityDtlEntity.getMaterialDesc());
                    mpInvMtlGroupEntity.setMaterialVer(mpInvActivityDtlEntity.getMaterialVer());
                    mpInvMtlGroupEntity.setMaterialVer(mpInvActivityDtlEntity.getMaterialVer());
                    mpInvMtlGroupEntity.setMtlState(MpInvMtlLocStateEnum.NORMAL.getCode());
                    mpInvMtlGroupEntity.setLotcontrolledFlag(mpInvActivityDtlEntity.getLotcontrolledFlag());
                    mpInvMtlGroupEntity.setSurplusQty(BigDecimal.ZERO);
                    mpInvMtlGroupEntity.setMtlKind(mpInvActivityDtlEntity.getMtlKind());

                    // 设置物料数量 计量单位 计量单位名称 lzk 2020/7/10
                    mpInvMtlGroupEntity.setMtlUom(mpInvActivityDtlEntity.getMtlUom());
                    String invActivity = mpInvActivityEntity.getInvActivity();
                    if (UNLOAD.getCode().equals(invActivity) || RECEIVE.getCode().equals(invActivity) || CANCELSTOCK.getCode().equals(invActivity)) {
                        // 当为收料、机台下料时，数量为正
                        mpInvMtlGroupEntity.setMtlQty(mpInvActivityDtlEntity.getMtlQty());
                    } else if (LOAD.getCode().equals(invActivity) || RETURN.getCode().equals(invActivity) || OUTSTOCK.getCode().equals(invActivity)) {
                        // 当为机台上料、退库时，数量为负
                        mpInvMtlGroupEntity.setMtlQty(null == mpInvActivityDtlEntity.getMtlQty() ? BigDecimal.ZERO : mpInvActivityDtlEntity.getMtlQty().negate());
                    } else {
                        // 正则加库存，负则减库存
                        mpInvMtlGroupEntity.setMtlQty(mpInvActivityDtlEntity.getMtlQty());
                    }
                    mpInvMtlGroupEntity.setMtlUomname(mpInvActivityDtlEntity.getMtlUomname());

                    // 放入物料活动明细id
                    mpInvMtlGroupEntity.setReceiptId(mpInvActivityDtlEntity.getId());
                    mpInvMtlGroupEntity.setActivityDetailId(mpInvActivityDtlEntity.getId());
                    mpInvMtlGroupEntity.preInsert();
                    mpInvMtlGroupEntity.setOrigingroupId(mpInvMtlGroupEntity.getId());
                    mpInvMtlGroupEntity.setOrigingroupNo(mpInvMtlGroupEntity.getMtlgroupNo());



                    /**
                     * edit by gel 2020/7/11
                     * 如果物料是序列管控则不需要保存批次的参数
                     */
                    McMtlMaterialEntity materialEntity = mcMtlMaterialDao.queryMcMtlMaterialById(htWmsMaterialInfoEntity.getId());
                    if (materialEntity != null && !YES.getWhether().equals(materialEntity.getSingletonFlag())) {
                        // 设置序列批次标识
                        mpInvMtlGroupEntity.setSerializedFlag(NO.getWhether());

                        List<McMtmMaterialParamEntity> matParamEntityList = mcMtmMaterialParamBo.findParamById(mpInvActivityDtlEntity.getMaterialId());
                        List<MpInvMtlGroupParamEntity> mpInvMtlGroupParamList = new ArrayList<>();
                        for (McMtmMaterialParamEntity matParamEntity : matParamEntityList) {
                            // 将物料的管控参数赋值给物料批次的参数
                            MpInvMtlGroupParamEntity mpInvMtlGroupParamEntity = new MpInvMtlGroupParamEntity();
                            mpInvMtlGroupParamEntity.setParentId(mpInvMtlGroupEntity.getId());
                            mpInvMtlGroupParamEntity.setParentType(InvActivityParamEnum.PARENT_TYPE.getCode());
                            mpInvMtlGroupParamEntity.setCtlparamType(matParamEntity.getCtlparamType());
                            mpInvMtlGroupParamEntity.setControlFlag(matParamEntity.getControlFlag());
                            mpInvMtlGroupParamEntity.setParamvalUnit(matParamEntity.getParamvalUnit());
                            mpInvMtlGroupParamEntity.setParamvalStd(matParamEntity.getParamvalStd());
                            mpInvMtlGroupParamEntity.setParamvalUnit(matParamEntity.getParamvalUnit());
                            // 预警值
                            mpInvMtlGroupParamEntity.setParamvalAlm(matParamEntity.getParamvalMin());
                            // 提前预警值
                            mpInvMtlGroupParamEntity.setParamvalPrealm(matParamEntity.getParamvalAlm());

                            if (YES.getWhether().equals(matParamEntity.getControlFlag())) {
                                if (cn.tfinfo.microservice.mes.basic.common.enums.ParamTypeEnum.ThawPDU.name().equals(matParamEntity.getCtlparamType())) {
                                    // 生成物料批次资料数据时判断物料是否需要卡控回温，如果需要则设置待回温状态
                                    mpInvMtlGroupEntity.setRewarmingState(MaterialRewarmingStateEnum.UnThaw.name());
                                    // 卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLimit(matParamEntity.getParamvalMax());
                                } else if (cn.tfinfo.microservice.mes.basic.common.enums.ParamTypeEnum.ThawCNT.name().equals(matParamEntity.getCtlparamType())) {
                                    // 卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLimit(matParamEntity.getParamvalMax());
                                    // 回温剩余次数设置为卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLeft(mpInvMtlGroupParamEntity.getParamvalLimit());
                                } else if (cn.tfinfo.microservice.mes.basic.common.enums.ParamTypeEnum.ValidDU.name().equals(matParamEntity.getCtlparamType())) {
                                    // 卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLimit(mpInvActivityDtlEntity.getValidityPeriod());
                                    //重新设置单位
                                    mpInvMtlGroupParamEntity.setParamvalUnit(mpInvActivityDtlEntity.getValidityUnit());
                                    if (mpInvActivityDtlEntity.getManufactureDate() != null) {
                                        // 设置计划开始时间，默认生成时只设置有效期的计划开始时间
                                        mpInvMtlGroupParamEntity.setStartTime(mpInvActivityDtlEntity.getManufactureDate());
                                        // 获取结束时间毫秒值
                                        long endTime = TimeUtils.getEndTime(
                                                mpInvMtlGroupParamEntity.getParamvalLimit() == null
                                                        ? null : mpInvMtlGroupParamEntity.getParamvalLimit().doubleValue(),
                                                mpInvMtlGroupParamEntity.getParamvalUnit(),
                                                mpInvMtlGroupParamEntity.getStartTime().getTime());
                                        // 设置有效期结束时间
                                        mpInvMtlGroupParamEntity.setSkdendTime(new Date(endTime));
                                    }
                                } else {
                                    // 卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLimit(matParamEntity.getParamvalMax());
                                }
                            } else if (NO.getWhether().equals(matParamEntity.getControlFlag())
                                    && cn.tfinfo.microservice.mes.basic.common.enums.ParamTypeEnum.ThawPDU.name().equals(matParamEntity.getCtlparamType())) {
                                // 不卡控直接设置为待使用 lzk 2020/7/10
                                mpInvMtlGroupEntity.setRewarmingState(MaterialRewarmingStateEnum.Thawed.name());
                            }

                            mpInvMtlGroupParamEntity.preInsert();
                            mpInvMtlGroupParamList.add(mpInvMtlGroupParamEntity);
                        }
                        if (CollectionUtils.isNotEmpty(mpInvMtlGroupParamList)) {
                            mpInvMtlGroupEntity.setMpInvMtlGroupParamEntityList(mpInvMtlGroupParamList);
                        }
                    } else if (materialEntity != null && YES.getWhether().equals(materialEntity.getSingletonFlag())) {
                        // 设置序列批次标识
                        mpInvMtlGroupEntity.setSerializedFlag(YES.getWhether());
                    }

                    // 生成物料库存位置实体类
                    MpInvMtlLocEntity mpInvMtlLocEntity = new MpInvMtlLocEntity();
                    mpInvMtlLocEntity.setMtlgroupKind(MtlGroupKind.MLOT.getCode());
                    mpInvMtlLocEntity.setMtlgroupNo(mpInvMtlGroupEntity.getMtlgroupNo());
                    mpInvMtlLocEntity.setMtlState(MpInvMtlLocStateEnum.NORMAL.getCode());
                    mpInvMtlLocEntity.setMtlgroupId(mpInvMtlGroupEntity.getId());
                    mpInvMtlLocEntity.setProdorgId(mpInvActivityEntity.getProdorgId());
                    mpInvMtlLocEntity.setLocationId(mpInvActivityDtlEntity.getLocationId());
                    mpInvMtlLocEntity.setLocationCode(mpInvActivityDtlEntity.getLocationCode());
                    mpInvMtlLocEntity.setLocationName(mpInvActivityDtlEntity.getLocationName());
                    // 收料位置类别默认线边仓
                    mpInvMtlLocEntity.setLocationKind(mpInvActivityDtlEntity.getLocationKind());
                    mpInvMtlLocEntity.setMaterialId(mpInvActivityDtlEntity.getMaterialId());
                    mpInvMtlLocEntity.setMaterialCode(mpInvActivityDtlEntity.getMaterialCode());
                    mpInvMtlLocEntity.setMaterialName(mpInvActivityDtlEntity.getMaterialName());
                    mpInvMtlLocEntity.setMaterialDesc(mpInvActivityDtlEntity.getMaterialDesc());
                    mpInvMtlLocEntity.setMaterialVer(mpInvActivityDtlEntity.getMaterialVer());
                    mpInvMtlLocEntity.setLotcontrolledFlag(mpInvActivityDtlEntity.getLotcontrolledFlag());
                    mpInvMtlLocEntity.setSerializedFlag(mpInvActivityDtlEntity.getSerializedFlag());
                    mpInvMtlLocEntity.setMtlUom(mpInvActivityDtlEntity.getMtlUom());
                    mpInvMtlLocEntity.setMtlUomname(mpInvActivityDtlEntity.getMtlUomname());
                    mpInvMtlLocEntity.setMtlSpu(mpInvActivityDtlEntity.getMtlSpu());
                    mpInvMtlLocEntity.setMtlSpuname(mpInvActivityDtlEntity.getMtlSpuname());
                    mpInvMtlLocEntity.setMtlSpuqty(mpInvActivityDtlEntity.getMtlSpuqty());
                    mpInvMtlLocEntity.setMtlKind(mpInvActivityDtlEntity.getMtlKind());

                    //todo 实体在basic，物料编码+批次暂时MTL_CODE_GOURP写入mtl_spuname
                    mpInvMtlLocEntity.setMtlSpuname(mpInvActivitySnHtWmsEntity.getMtlgroupNo());

                    if (UNLOAD.getCode().equals(invActivity) || RECEIVE.getCode().equals(invActivity) || CANCELSTOCK.getCode().equals(invActivity)) {
                        // 当为收料、机台下料时，数量为正
                        mpInvMtlLocEntity.setMtlQty(mpInvActivityDtlEntity.getMtlQty());
                        mpInvMtlLocEntity.setMtlSpuqty(null == mpInvActivityDtlEntity.getMtlSpuqty() ? 0L : mpInvActivityDtlEntity.getMtlSpuqty());
                    } else if (LOAD.getCode().equals(invActivity) || RETURN.getCode().equals(invActivity) || OUTSTOCK.getCode().equals(invActivity)) {
                        // 判断当前库存数量是否还够扣
                        List<MpInvMtlLocEntity> mpInvMtlLocList = mpInvMtlLocDao.findCurrentQtyByMtlgroupNoList(mpInvMtlGroupEntity.getMtlgroupNo(), mpInvActivityDtlEntity.getLocationId());
                        if (CollectionUtils.isNotEmpty(mpInvMtlLocList)) {
                            MpInvMtlLocEntity oldMpInvMtlLocEntity = mpInvMtlLocList.get(0);
                            if (mpInvActivityDtlEntity.getMtlQty().compareTo(oldMpInvMtlLocEntity.getMtlQty()) > 0) {
                                return null;
                            }
                        }

                        // 当为机台上料、退库时，数量为负
                        mpInvMtlLocEntity.setMtlQty(null == mpInvActivityDtlEntity.getMtlQty() ? BigDecimal.ZERO : mpInvActivityDtlEntity.getMtlQty().negate());
                        mpInvMtlLocEntity.setMtlSpuqty(null == mpInvActivityDtlEntity.getMtlSpuqty() ? 0L : -mpInvActivityDtlEntity.getMtlSpuqty());
                    } else {
                        // 正则加库存，负则减库存
                        mpInvMtlLocEntity.setMtlQty(mpInvActivityDtlEntity.getMtlQty());
                    }
                    mpInvMtlLocEntity.preInsert();
                    mpInvMtlGroupEntity.getMpInvMtlLocList().add(mpInvMtlLocEntity);
                    mpInvMtlGroupList.add(mpInvMtlGroupEntity);
                    mpInvActivityDtlEntity.setMtlgroupId(mpInvMtlGroupEntity.getId());
                    mpInvActivityDtlEntity.setMtllocId(mpInvMtlLocEntity.getId());



                }
            }



        }
        return mpInvMtlGroupList;
    }



    /**
     * eizo 2025-04-25 根据物料收料活动数据生成物料库存数据实体类
     *
     * @param mpInvActivityEntity 物料活动数据
     * @return 返回物料库存数据
     */
    private List<MpInvMtlGroupEntity> getMpInvMtlGroupEntityHtWmsNew(MpInvActivityEntity mpInvActivityEntity) {
        List<MpInvMtlGroupEntity> mpInvMtlGroupList = new ArrayList<>();
        List<MpInvActivityDtlEntity> mpInvActivityDtlList = mpInvActivityEntity.getMpInvActivityDtlList();

        String fromLocationId = null;
        for (MpInvActivityDtlEntity mpInvActivityDtlEntity : mpInvActivityDtlList) {

            //车间退料--只处理来源
            if(mpInvActivityEntity.getMoveMaterialType().equals("returnWms")){
                if(MovelocTypeEnum.TO.getCode().equals(mpInvActivityDtlEntity.getMovelocType())){
                    continue;
                }
            }
            else if (MovelocTypeEnum.FROM.getCode().equals(mpInvActivityDtlEntity.getMovelocType())) {
                fromLocationId = mpInvActivityDtlEntity.getLocationId();
                continue;
            }




//                    //eizo 2025-04-21 更新唯一性批号和条码数量，条码和数量进行调整
//                    mpInvActivityDtlEntity.setBatchNo(mpInvActivitySnHtWmsEntity.getMaterialBarcode());
//                    mpInvActivityDtlEntity.setMtlQty(mpInvActivitySnHtWmsEntity.getMaterialQty());
//                    //生产日期
//                    mpInvActivityDtlEntity.setManufactureDate(mpInvActivitySnHtWmsEntity.getManufactureDate());
//                    //失效日期-生产日期
//                    // 解析字符串为LocalDate对象
//                    LocalDate date1 = LocalDate.parse(DateUtils.dateToStr(mpInvActivitySnHtWmsEntity.getManufactureDate(), DateConstant.FORMAT_YYYY_MM_DD));
//                    LocalDate date2 = LocalDate.parse(DateUtils.dateToStr(mpInvActivitySnHtWmsEntity.getDvDate(), DateConstant.FORMAT_YYYY_MM_DD));

//                    // 使用ChronoUnit计算天数差
//                    long daysBetween = ChronoUnit.DAYS.between(date1, date2);
//                    BigDecimal validityPeriod = BigDecimal.valueOf(daysBetween);
//                    mpInvActivityDtlEntity.setValidityPeriod(validityPeriod);
//                    mpInvActivityDtlEntity.setValidityUnit("D");
//                    //eizo 2025-04-21 物料编码查询物料ID
//                    HtWmsMaterialInfoEntity htWmsMaterialInfoEntity = htWmsBaseDao.findMtlByMtlCode(mpInvActivityDtlEntity.getMaterialCode());
//                    mpInvActivityDtlEntity.setMaterialId(htWmsMaterialInfoEntity.getId());
//                    mpInvActivityDtlEntity.setMaterialVer(htWmsMaterialInfoEntity.getRevision());
//                    mpInvActivityDtlEntity.setMtlKind(htWmsMaterialInfoEntity.getMtlKind());
//                    mpInvActivityDtlEntity.setMtlUom(htWmsMaterialInfoEntity.getMtlUom());


                    //之前记录了物料条码的产品数量，而且也不启用原序列号功能
//                    mpInvActivityDtlEntity.setMtlSpuqty(Long.valueOf(0));



                    MpInvMtlGroupEntity mpInvMtlGroupEntity = new MpInvMtlGroupEntity(new ArrayList<>(), new ArrayList<>());
                    // 物料库存类别，默认物料批次
                    mpInvMtlGroupEntity.setMtlgroupKind(MtlGroupKind.MLOT.getCode());
                    mpInvMtlGroupEntity.setMtlgroupNo(mpInvActivityDtlEntity.getBatchNo());
                    mpInvMtlGroupEntity.setMaterialId(mpInvActivityDtlEntity.getMaterialId());
                    mpInvMtlGroupEntity.setMaterialCode(mpInvActivityDtlEntity.getMaterialCode());
                    mpInvMtlGroupEntity.setMaterialName(mpInvActivityDtlEntity.getMaterialName());
                    mpInvMtlGroupEntity.setMaterialDesc(mpInvActivityDtlEntity.getMaterialDesc());
                    mpInvMtlGroupEntity.setMaterialVer(mpInvActivityDtlEntity.getMaterialVer());
                    mpInvMtlGroupEntity.setMaterialVer(mpInvActivityDtlEntity.getMaterialVer());
                    mpInvMtlGroupEntity.setMtlState(MpInvMtlLocStateEnum.NORMAL.getCode());
                    mpInvMtlGroupEntity.setLotcontrolledFlag(mpInvActivityDtlEntity.getLotcontrolledFlag());
                    mpInvMtlGroupEntity.setSurplusQty(BigDecimal.ZERO);
                    mpInvMtlGroupEntity.setMtlKind(mpInvActivityDtlEntity.getMtlKind());

                    // 设置物料数量 计量单位 计量单位名称 lzk 2020/7/10
                    mpInvMtlGroupEntity.setMtlUom(mpInvActivityDtlEntity.getMtlUom());
                    String invActivity = mpInvActivityEntity.getInvActivity();
                    if (UNLOAD.getCode().equals(invActivity) || RECEIVE.getCode().equals(invActivity) || CANCELSTOCK.getCode().equals(invActivity)) {
                        // 当为收料、机台下料时，数量为正
                        mpInvMtlGroupEntity.setMtlQty(mpInvActivityDtlEntity.getMtlQty());
                    } else if (LOAD.getCode().equals(invActivity) || RETURN.getCode().equals(invActivity) || OUTSTOCK.getCode().equals(invActivity)) {
                        // 当为机台上料、退库时，数量为负
                        mpInvMtlGroupEntity.setMtlQty(null == mpInvActivityDtlEntity.getMtlQty() ? BigDecimal.ZERO : mpInvActivityDtlEntity.getMtlQty().negate());
                    } else {
                        // 正则加库存，负则减库存
                        //车间退料
                        if(mpInvActivityEntity.getMoveMaterialType().equals("returnWms")){
                            mpInvMtlGroupEntity.setMtlQty(null == mpInvActivityDtlEntity.getMtlQty() ? BigDecimal.ZERO : mpInvActivityDtlEntity.getMtlQty().negate());
                        }
                        else{
                            mpInvMtlGroupEntity.setMtlQty(mpInvActivityDtlEntity.getMtlQty());
                        }


                    }
                    mpInvMtlGroupEntity.setMtlUomname(mpInvActivityDtlEntity.getMtlUomname());

                    // 放入物料活动明细id
                    mpInvMtlGroupEntity.setReceiptId(mpInvActivityDtlEntity.getId());
                    mpInvMtlGroupEntity.setActivityDetailId(mpInvActivityDtlEntity.getId());
                    mpInvMtlGroupEntity.preInsert();
                    mpInvMtlGroupEntity.setOrigingroupId(mpInvMtlGroupEntity.getId());
                    mpInvMtlGroupEntity.setOrigingroupNo(mpInvMtlGroupEntity.getMtlgroupNo());

                    //补充物料的批号
                     mpInvMtlGroupEntity.setOriginBatchNo(mpInvActivityDtlEntity.getOriginBatchNo());
                     mpInvMtlGroupEntity.setMaterialCodeMb(mpInvActivityDtlEntity.getMtlgroupNoWms());


                    /**
                     * edit by gel 2020/7/11
                     * 如果物料是序列管控则不需要保存批次的参数
                     */
                    McMtlMaterialEntity materialEntity = mcMtlMaterialDao.queryMcMtlMaterialById(mpInvActivityDtlEntity.getMaterialId());
                    if (materialEntity != null && !YES.getWhether().equals(materialEntity.getSingletonFlag())) {
                        // 设置序列批次标识
                        mpInvMtlGroupEntity.setSerializedFlag(NO.getWhether());

                        List<McMtmMaterialParamEntity> matParamEntityList = mcMtmMaterialParamBo.findParamById(mpInvActivityDtlEntity.getMaterialId());
                        List<MpInvMtlGroupParamEntity> mpInvMtlGroupParamList = new ArrayList<>();
                        for (McMtmMaterialParamEntity matParamEntity : matParamEntityList) {
                            // 将物料的管控参数赋值给物料批次的参数
                            MpInvMtlGroupParamEntity mpInvMtlGroupParamEntity = new MpInvMtlGroupParamEntity();
                            mpInvMtlGroupParamEntity.setParentId(mpInvMtlGroupEntity.getId());
                            mpInvMtlGroupParamEntity.setParentType(InvActivityParamEnum.PARENT_TYPE.getCode());
                            mpInvMtlGroupParamEntity.setCtlparamType(matParamEntity.getCtlparamType());
                            mpInvMtlGroupParamEntity.setControlFlag(matParamEntity.getControlFlag());
                            mpInvMtlGroupParamEntity.setParamvalUnit(matParamEntity.getParamvalUnit());
                            mpInvMtlGroupParamEntity.setParamvalStd(matParamEntity.getParamvalStd());
                            mpInvMtlGroupParamEntity.setParamvalUnit(matParamEntity.getParamvalUnit());
                            // 预警值
                            mpInvMtlGroupParamEntity.setParamvalAlm(matParamEntity.getParamvalMin());
                            // 提前预警值
                            mpInvMtlGroupParamEntity.setParamvalPrealm(matParamEntity.getParamvalAlm());

                            if (YES.getWhether().equals(matParamEntity.getControlFlag())) {
                                if (cn.tfinfo.microservice.mes.basic.common.enums.ParamTypeEnum.ThawPDU.name().equals(matParamEntity.getCtlparamType())) {
                                    // 生成物料批次资料数据时判断物料是否需要卡控回温，如果需要则设置待回温状态
                                    mpInvMtlGroupEntity.setRewarmingState(MaterialRewarmingStateEnum.UnThaw.name());
                                    // 卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLimit(matParamEntity.getParamvalMax());
                                } else if (cn.tfinfo.microservice.mes.basic.common.enums.ParamTypeEnum.ThawCNT.name().equals(matParamEntity.getCtlparamType())) {
                                    // 卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLimit(matParamEntity.getParamvalMax());
                                    // 回温剩余次数设置为卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLeft(mpInvMtlGroupParamEntity.getParamvalLimit());
                                } else if (cn.tfinfo.microservice.mes.basic.common.enums.ParamTypeEnum.ValidDU.name().equals(matParamEntity.getCtlparamType())) {
                                    // 卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLimit(mpInvActivityDtlEntity.getValidityPeriod());
                                    //重新设置单位
                                    mpInvMtlGroupParamEntity.setParamvalUnit(mpInvActivityDtlEntity.getValidityUnit());
                                    if (mpInvActivityDtlEntity.getManufactureDate() != null) {
                                        // 设置计划开始时间，默认生成时只设置有效期的计划开始时间
                                        mpInvMtlGroupParamEntity.setStartTime(mpInvActivityDtlEntity.getManufactureDate());
                                        // 获取结束时间毫秒值
                                        long endTime = TimeUtils.getEndTime(
                                                mpInvMtlGroupParamEntity.getParamvalLimit() == null
                                                        ? null : mpInvMtlGroupParamEntity.getParamvalLimit().doubleValue(),
                                                mpInvMtlGroupParamEntity.getParamvalUnit(),
                                                mpInvMtlGroupParamEntity.getStartTime().getTime());
                                        // 设置有效期结束时间
                                        mpInvMtlGroupParamEntity.setSkdendTime(new Date(endTime));
                                    }
                                } else {
                                    // 卡控值
                                    mpInvMtlGroupParamEntity.setParamvalLimit(matParamEntity.getParamvalMax());
                                }
                            } else if (NO.getWhether().equals(matParamEntity.getControlFlag())
                                    && cn.tfinfo.microservice.mes.basic.common.enums.ParamTypeEnum.ThawPDU.name().equals(matParamEntity.getCtlparamType())) {
                                // 不卡控直接设置为待使用 lzk 2020/7/10
                                mpInvMtlGroupEntity.setRewarmingState(MaterialRewarmingStateEnum.Thawed.name());
                            }

                            mpInvMtlGroupParamEntity.preInsert();
                            mpInvMtlGroupParamList.add(mpInvMtlGroupParamEntity);
                        }
                        if (CollectionUtils.isNotEmpty(mpInvMtlGroupParamList)) {
                            mpInvMtlGroupEntity.setMpInvMtlGroupParamEntityList(mpInvMtlGroupParamList);
                        }
                    } else if (materialEntity != null && YES.getWhether().equals(materialEntity.getSingletonFlag())) {
                        // 设置序列批次标识
                        mpInvMtlGroupEntity.setSerializedFlag(YES.getWhether());
                    }

                    // 生成物料库存位置实体类
                    MpInvMtlLocEntity mpInvMtlLocEntity = new MpInvMtlLocEntity();
                    mpInvMtlLocEntity.setMtlgroupKind(MtlGroupKind.MLOT.getCode());
                    mpInvMtlLocEntity.setMtlgroupNo(mpInvMtlGroupEntity.getMtlgroupNo());
                    mpInvMtlLocEntity.setMtlState(MpInvMtlLocStateEnum.NORMAL.getCode());
                    mpInvMtlLocEntity.setMtlgroupId(mpInvMtlGroupEntity.getId());
                    mpInvMtlLocEntity.setProdorgId(mpInvActivityEntity.getProdorgId());
                    mpInvMtlLocEntity.setLocationId(mpInvActivityDtlEntity.getLocationId());
                    mpInvMtlLocEntity.setLocationCode(mpInvActivityDtlEntity.getLocationCode());
                    mpInvMtlLocEntity.setLocationName(mpInvActivityDtlEntity.getLocationName());
                    // 收料位置类别默认线边仓
                    mpInvMtlLocEntity.setLocationKind(mpInvActivityDtlEntity.getLocationKind());
                    mpInvMtlLocEntity.setMaterialId(mpInvActivityDtlEntity.getMaterialId());
                    mpInvMtlLocEntity.setMaterialCode(mpInvActivityDtlEntity.getMaterialCode());
                    mpInvMtlLocEntity.setMaterialName(mpInvActivityDtlEntity.getMaterialName());
                    mpInvMtlLocEntity.setMaterialDesc(mpInvActivityDtlEntity.getMaterialDesc());
                    mpInvMtlLocEntity.setMaterialVer(mpInvActivityDtlEntity.getMaterialVer());
                    mpInvMtlLocEntity.setLotcontrolledFlag(mpInvActivityDtlEntity.getLotcontrolledFlag());
                    mpInvMtlLocEntity.setSerializedFlag(mpInvActivityDtlEntity.getSerializedFlag());
                    mpInvMtlLocEntity.setMtlUom(mpInvActivityDtlEntity.getMtlUom());
                    mpInvMtlLocEntity.setMtlUomname(mpInvActivityDtlEntity.getMtlUomname());
                    mpInvMtlLocEntity.setMtlSpu(mpInvActivityDtlEntity.getMtlSpu());
                    mpInvMtlLocEntity.setMtlSpuname(mpInvActivityDtlEntity.getMtlSpuname());
                    mpInvMtlLocEntity.setMtlSpuqty(mpInvActivityDtlEntity.getMtlSpuqty());
                    mpInvMtlLocEntity.setMtlKind(mpInvActivityDtlEntity.getMtlKind());

                    //todo 实体在basic，物料编码+批次暂时MTL_CODE_GOURP写入mtl_spuname
                    mpInvMtlLocEntity.setMtlSpuname(mpInvActivityDtlEntity.getMtlgroupNoWms());
                    //补充物料批次
                    mpInvMtlLocEntity.setOriginBatchNo(mpInvActivityDtlEntity.getOriginBatchNo());
                    mpInvMtlLocEntity.setMaterialCodeMb(mpInvActivityDtlEntity.getMtlgroupNoWms());

                    if (UNLOAD.getCode().equals(invActivity) || RECEIVE.getCode().equals(invActivity) || CANCELSTOCK.getCode().equals(invActivity)) {
                        // 当为收料、机台下料时，数量为正
                        mpInvMtlLocEntity.setMtlQty(mpInvActivityDtlEntity.getMtlQty());
                        mpInvMtlLocEntity.setMtlSpuqty(null == mpInvActivityDtlEntity.getMtlSpuqty() ? 0L : mpInvActivityDtlEntity.getMtlSpuqty());
                    } else if (LOAD.getCode().equals(invActivity) || RETURN.getCode().equals(invActivity) || OUTSTOCK.getCode().equals(invActivity)) {
                        // 判断当前库存数量是否还够扣
                        List<MpInvMtlLocEntity> mpInvMtlLocList = mpInvMtlLocDao.findCurrentQtyByMtlgroupNoList(mpInvMtlGroupEntity.getMtlgroupNo(), mpInvActivityDtlEntity.getLocationId());
                        if (CollectionUtils.isNotEmpty(mpInvMtlLocList)) {
                            MpInvMtlLocEntity oldMpInvMtlLocEntity = mpInvMtlLocList.get(0);
                            if (mpInvActivityDtlEntity.getMtlQty().compareTo(oldMpInvMtlLocEntity.getMtlQty()) > 0) {
                                return null;
                            }
                        }

                        // 当为机台上料、退库时，数量为负
                        mpInvMtlLocEntity.setMtlQty(null == mpInvActivityDtlEntity.getMtlQty() ? BigDecimal.ZERO : mpInvActivityDtlEntity.getMtlQty().negate());
                        mpInvMtlLocEntity.setMtlSpuqty(null == mpInvActivityDtlEntity.getMtlSpuqty() ? 0L : -mpInvActivityDtlEntity.getMtlSpuqty());
                    } else {
                        // 正则加库存，负则减库存

                        //车间退料
                        if(mpInvActivityEntity.getMoveMaterialType().equals("returnWms")){
                            mpInvMtlLocEntity.setMtlQty(null == mpInvActivityDtlEntity.getMtlQty() ? BigDecimal.ZERO : mpInvActivityDtlEntity.getMtlQty().negate());
                        }
                        else{
                            mpInvMtlLocEntity.setMtlQty(mpInvActivityDtlEntity.getMtlQty());
                        }


                    }
                    mpInvMtlLocEntity.preInsert();
                    mpInvMtlGroupEntity.getMpInvMtlLocList().add(mpInvMtlLocEntity);
                    mpInvMtlGroupList.add(mpInvMtlGroupEntity);
                    mpInvActivityDtlEntity.setMtlgroupId(mpInvMtlGroupEntity.getId());
                    mpInvActivityDtlEntity.setMtllocId(mpInvMtlLocEntity.getId());








        }
        return mpInvMtlGroupList;
    }

    /**
     * 获取物料编码规则并生成对应编号
     *
     * @param materialCode
     * @param parentLotNo
     * @return
     */
    private SerialResultEntity findRuleAndCreateNo(String materialCode, String parentLotNo) {
        SerialResultEntity serialResult = new SerialResultEntity();
        serialResult.error();
        String ruleId = mcComNumRuleBo.findMtlRuleId(materialCode, INVSUBLOT);
        if (StringUtils.isEmpty(ruleId)) {
            return serialResult;
        }
        SubLotEntity subLotEntity = new SubLotEntity();
        subLotEntity.setParentLotNo(parentLotNo);
        subLotEntity.setMaterialCode(materialCode);
        serialResult = ruleSerialBo.checkFiledAndCreateNum(ruleId, subLotEntity);
        return serialResult;
    }

    /**
     * 获取序列号列表
     *
     * @param mpInvActivityDtlEntity
     * @param toolingList
     * @param serialList
     */
    private BaseReturn getSnList(MpInvActivityDtlEntity mpInvActivityDtlEntity, List<McMtmToolingEntity> toolingList, List<McMtmSerialmtlEntity> serialList, BaseReturn result) {
        List<MpInvActivitySnEntity> mpInvActivitySnList = mpInvActivityDtlEntity.getMpInvActivitySnList();
        if (MovelocTypeEnum.FROM.getCode().equals(mpInvActivityDtlEntity.getMovelocType()) || CollectionUtils.isEmpty(mpInvActivitySnList)) {
            return result;
        }
        String locId;
        List<String> locInfoList = mpInvMtlLocDao.findMpInvMtlLocExists(mpInvActivityDtlEntity.getBatchNo(), mpInvActivityDtlEntity.getLocationId());
        if (CollectionUtils.isNotEmpty(locInfoList)) {
            locId = locInfoList.get(0);
        } else {
            locId = mpInvActivityDtlEntity.getMtllocId();
        }

        // 验证版本号是否被更新
        int size = mpInvActivitySnList.size();
        List<String> snIdList = new ArrayList<>(size);
        mpInvActivitySnList.forEach(sn -> snIdList.add(sn.getSerialmtlId()));

        List<String> toolingSnList = mpInvActivitySnList.stream().map(MpInvActivitySnEntity::getMaterialSn).collect(Collectors.toList());
        String mtlKind = mpInvActivityDtlEntity.getMtlKind();

        // 校验版本号
        List<McMtmSerialmtlEntity> serialmtlVerNoList = mcMtmSerialmtlBo.findSerialmtlVerNoByIdList(snIdList);
        Map<String, McMtmSerialmtlEntity> serialmtlVerNoMap = new HashMap<>(size);
        serialmtlVerNoList.forEach(serialmtl -> serialmtlVerNoMap.put(serialmtl.getId(), serialmtl));
        for (MpInvActivitySnEntity sn : mpInvActivitySnList) {
            McMtmSerialmtlEntity snEntity = serialmtlVerNoMap.get(sn.getSerialmtlId());
            if (null != snEntity && !sn.getVerNo().equals(snEntity.getVerNo())) {
                result.error(DATA_ALREADY_BE_UPDATED);
                return result;
            }
        }

        // 修改化学品数据位置
        McMtmSerialmtlEntity serialmtlEntity = new McMtmSerialmtlEntity();
        serialmtlEntity.setMaterialSnList(toolingSnList);
        serialmtlEntity.setLocType(mpInvActivityDtlEntity.getLocationKind());
        serialmtlEntity.setLocId(mpInvActivityDtlEntity.getLocationId());
        serialmtlEntity.setLocCode(mpInvActivityDtlEntity.getLocationCode());
        serialmtlEntity.setLocName(mpInvActivityDtlEntity.getLocationName());
        serialmtlEntity.setMtlgroupNo(mpInvActivityDtlEntity.getBatchNo());
        serialmtlEntity.setMtllocId(locId);
        serialmtlEntity.setMtlgroupId(mpInvMtlLocDao.findMpInvMtlLocById(locId).getMtlgroupId());
        serialmtlEntity.preUpdate();
        serialList.add(serialmtlEntity);

        return result;
    }



    public McMtmTemperatureEntity getTemperatureList(String batchNo) {

        McMtmTemperatureEntity mcMtmSerialmtlEntity = mcMtmSerialmtlBo.getTemperatureList(batchNo);


        return mcMtmSerialmtlEntity;
    }

    public McMtmTemperatureEntity getTemperatureListBySN(String batchNo) {
        return mcMtmSerialmtlBo.getTemperatureListBySN(batchNo);
    }

    public List<McMtmTemperatureEntity> getMaterialCodeByLotNo(String batchNo,String workcenterId) {

        List<McMtmTemperatureEntity> mcMtmSerialmtlEntity = mcMtmSerialmtlBo.getMaterialCodeByLotNo(batchNo,workcenterId);


        return mcMtmSerialmtlEntity;
    }

    /**
     * 生成编码
     * @param mpInvActivityEntity
     * @param ruleId
     * @return
     */
    public SerialResultEntity createMoveMtlNo(MpInvActivityEntity mpInvActivityEntity, String ruleId) {
        SubLotEntity subLotEntity = new SubLotEntity();
        List<DeptEntity> deptList = userUtil.findDeptName();
        subLotEntity.setDeptCode(CollectionUtils.isEmpty(deptList) ? StringUtils.EMPTY_STRING : deptList.get(0).getDeptCode());

        SerialResultEntity serialResult = ruleSerialBo.checkFiledAndCreateNum(ruleId, subLotEntity);
        mpInvActivityEntity.setOrderNo(serialResult.getSerialNo());
        if (serialResult.getSerialFlag() && CollectionUtils.isNotEmpty(deptList)) {
            mpInvActivityEntity.setDeptId(deptList.get(0).getDeptId());
            mpInvActivityEntity.setDeptCode(deptList.get(0).getDeptCode());
            mpInvActivityEntity.setDeptName(deptList.get(0).getDeptName());
        }
        return serialResult;
    }


    /**
     * 当为“生产批、工单”时，移料来源单号必填，且做存在性校验；为“其它”时，可为空
     * @param moveMaterialSource
     * @param sourceNo
     * @return
     */
    public boolean checkExistBySource(String moveMaterialSource, String sourceNo) {

        if (MoveMaterialSourceEnum.MP_LOT.getCode().equals(moveMaterialSource)) {
            if (StringUtils.isEmpty(sourceNo)) {
                return false;
            }
            //根据批次号查批次
            return null != mpLotDao.findLotByLotNo(sourceNo);
        }

        if (MoveMaterialSourceEnum.MP_WORK_ORDER.getCode().equals(moveMaterialSource)) {
            if (StringUtils.isEmpty(sourceNo)) {
                return false;
            }
            //根据工单查询
            return null != mpWorkorderDao.queryMpWorkOrderByWoCode(sourceNo);
        }
        return true;
    }

    public Integer countMpInvMtlLocList(MpInvMtlLocEntityExetend mpInvMtlLocEntity) {
        return mpMtlMoveDao.countMpInvMtlLocList(mpInvMtlLocEntity);
    }

    @PageList
    public List<MpInvMtlLocEntity> findMpInvMtlLocList(MpInvMtlLocEntityExetend mpInvMtlLocEntity,Boolean preciousFlag) {
        List<MpInvMtlLocEntity> mpInvMtlLocList ;
        if(preciousFlag){
            mpInvMtlLocList = mpMtlMoveDao.findMpInvMtlLocListPrecious(mpInvMtlLocEntity);
        } else {
            mpInvMtlLocList = mpMtlMoveDao.findMpInvMtlLocList(mpInvMtlLocEntity);
        }

        if (CollectionUtils.isEmpty(mpInvMtlLocList)) {
            return mpInvMtlLocList;
        }
        // 转换位置类型
        mpInvMtlLocList.forEach(mpMtlMoveEntity -> {
            // 转换位置类型
            if (StringUtils.isNotEmpty(mpMtlMoveEntity.getLocationKind())) {
                mpMtlMoveEntity.setLocationKindName(DictBo.getDictLabel(mpMtlMoveEntity.getLocationKind(),
                        DictType.MP_INV_MTLLOC_LOCATION_KIND, null));
            }
            // 转换物料类型
            if (StringUtils.isNotEmpty(mpMtlMoveEntity.getMtlKind())) {
                mpMtlMoveEntity.setMtlKindName(DictBo.getDictLabel(mpMtlMoveEntity.getMtlKind(),
                        DictType.MC_MTL_MATERIAL_KIND, null));
            }
        });

        //为生产日期和保质期赋值
        //查出生产日期....
        List<String> mtlGroupNos = mpInvMtlLocList.stream().map(MpInvMtlLocEntity::getMtlgroupNo).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(mtlGroupNos)) {
            return mpInvMtlLocList;
        }
        List<String> receiptIds = mpInvMtlGroupDao.getMpInvMtlGroupReceiptIds(mtlGroupNos);
        if (CollectionUtils.isEmpty(receiptIds)) {
            return mpInvMtlLocList;
        }
        List<MpInvActivityDtlEntity> list = mpInvActivityDtlDao.findMpInvActivityDtlListByIds(receiptIds);
        if (CollectionUtils.isEmpty(list)) {
            return mpInvMtlLocList;
        }
        for (MpInvMtlLocEntity invMtlLocEntity : mpInvMtlLocList) {
            list.forEach(item -> {
                if (invMtlLocEntity.getMtlgroupNo().equals(item.getBatchNo())) {
                    invMtlLocEntity.setManufactureDate(item.getManufactureDate());
                    invMtlLocEntity.setManufactureDateStr(DateUtils.dateToStr(invMtlLocEntity.getManufactureDate(), DateConstant.FORMAT_YYYY_MM_DD_HH_MM_SS));
                    //赋值有效期
                    invMtlLocEntity.setValidityPeriod(item.getValidityPeriod());
                    invMtlLocEntity.setValidityUnit(item.getValidityUnit());
                }
            });
        }

        //计算剩余有效期
        mpInvMtlLocList.forEach(this::calculateRemainPeriod);
        //剩余有效期转为分钟为单位
        mpInvMtlLocList.forEach(this::calculateRemainPeriod2Minutes);
        mpInvMtlLocList.sort(Comparator.comparing(MpInvMtlLocEntity::getRemainPeriodMinutes,
                Comparator.nullsFirst(Comparator.naturalOrder())));
        return mpInvMtlLocList;
    }


    public BaseReturn checkAvailable(List<MpInvMtlLocEntity> selectedList, String moveMaterialType,
                                     String prodorgId, String locationKind, String locationId) {
        BaseReturn baseReturn = new BaseReturn<>(BaseErrorCode.SUCCESS);
        log.info("the selectedList is : [{}]",JSON.toJSONString(selectedList));
        //根据物料 料号 划分出 list
        Map<String, List<MpInvMtlLocEntity>> selectedMap = selectedList.stream().collect(Collectors.groupingBy(MpInvMtlLocEntity::getMaterialCode));
        if (CollectionUtils.isEmpty(selectedMap.keySet())) {
            log.error("selected MaterialCode list :[{}] is null",JSON.toJSONString(selectedMap.keySet()));
            baseReturn.error(BaseErrorCode.PARAM_ERROR);
            return baseReturn;
        }
        //查出物料下的所有批次
        List<MpInvMtlLocEntity> list = mpMtlMoveDao.findMpInvMtlListByMaterialCode(selectedMap.keySet(),prodorgId,locationKind,locationId);
        if (CollectionUtils.isEmpty(list)) {
            log.error("query MaterialCode list :[{}] from db is null",JSON.toJSONString(selectedMap.keySet()));
            baseReturn.error(BaseErrorCode.PARAM_ERROR);
            return baseReturn;
        }
        //根据物料 料号 划分 出 list
        Map<String, List<MpInvMtlLocEntity>> materialMap = list.stream().collect(Collectors.groupingBy(MpInvMtlLocEntity::getMaterialCode));

        StringBuilder builder = new StringBuilder();
        Boolean flag = true;
        for (String materialCode : selectedMap.keySet()) {
            //拿出该 materialCode 前端已选择的 list
            List<MpInvMtlLocEntity> selectList = selectedMap.get(materialCode);
            log.info("materialCode is : [{}] ,selectList is [{}]",materialCode,JSON.toJSONString(selectedList));
            //拿出数据库中该 materialCode 下属所有批次
            List<MpInvMtlLocEntity> fromDbList = materialMap.get(materialCode);
            log.info("materialCode is : [{}] ,fromDbList is [{}]",materialCode,JSON.toJSONString(fromDbList));
            //数据库中未查到该 materialCode 下属批次
            if (CollectionUtils.isEmpty(fromDbList)) {
                log.error("query MaterialCode :[{}] from db is null",materialCode);
                baseReturn.error(BaseErrorCode.PARAM_ERROR);
                return baseReturn;
            }
            //赋值生产日期和有效期
            setManufactureDateAndValidityPeriod(fromDbList);
            //计算剩余有效时间
            fromDbList.forEach(this::calculateRemainPeriod);

            //如果是生产领用,需要先把 list 里面的剩余有效时间小于 0 的先过滤掉,再比较
//            if (MoveMaterialTypeEnum.MOVE_RECEIVE.getCode().equals(moveMaterialType)) {
//                fromDbList = fromDbList.stream()
//                        .filter(item -> (null != item.getRemainPeriod() && BigDecimal.ZERO.compareTo(item.getRemainPeriod()) < 0))
//                        .collect(Collectors.toList());
//            }

            //当选中物料存在有效期更短数据时，做提示确认，提示内容：存在更短有效期物料，是否确定使用选中批次？
            //比较前端选中的列表在前多少个
            Boolean theSame = compareTwoListWithSort(selectList,fromDbList);
            if (!theSame) {
                builder.append(materialCode).append("、");
                flag = false;
            }
        }
        if (!flag) {
            //去除最后一位
            builder.deleteCharAt(builder.length() - 1);
            String s = builder.toString();
            baseReturn.error(BaseSysCodeEnums.SHORTER_VALIDITY_PERIOD.getCode()
                    ,String.format(BaseSysCodeEnums.SHORTER_VALIDITY_PERIOD.getMsg(),s));
            return baseReturn;
        }
        return baseReturn;
    }

    /**
     * 当选中物料存在有效期更短数据时，做提示确认，提示内容：存在更短有效期物料，是否确定使用选中批次？
     * @param selectList 前端选中的物料 list
     * @param fromDbList 后端数据出查出的物料 list
     * @return
     */
    private Boolean compareTwoListWithSort(List<MpInvMtlLocEntity> selectList, List<MpInvMtlLocEntity> fromDbList) {
        //全部转换成用分钟为单位
        selectList.forEach(this::calculateRemainPeriod2Minutes);
        fromDbList.forEach(this::calculateRemainPeriod2Minutes);
        //按剩余有效期排序从小到大排序
        selectList.sort(Comparator.comparing(MpInvMtlLocEntity::getRemainPeriodMinutes,
                Comparator.nullsFirst(Comparator.naturalOrder())));
        log.info("sorted selectList is : [{}]", JSON.toJSONString(selectList));

        fromDbList.sort(Comparator.comparing(MpInvMtlLocEntity::getRemainPeriodMinutes,
                Comparator.nullsFirst(Comparator.naturalOrder())));
        log.info("sorted fromDbList is : [{}]", JSON.toJSONString(fromDbList));
        //拿出前端选择的 list 最后一个元素
        MpInvMtlLocEntity selectedBiggest = selectList.get(selectList.size() - 1);
        //在数据库查出的 list 中找出对应的元素
        MpInvMtlLocEntity itemInFromDbList = fromDbList.stream()
                .filter(item -> selectedBiggest.getId().equals(item.getId()))
                .findFirst().orElse(null);
        if (null == itemInFromDbList) {
            log.error("在 fromDbList 中没有找到对应的元素，未知错误");
            return false;
        }
        //看这个元素是否在 fromDbList 对应大小的 index 如果在就认为前端选择了前多少个
        int size = selectList.size();
        int index = fromDbList.indexOf(itemInFromDbList);
        log.info("index in fromDbList is : [{}]",index);
        return index == size - 1;
    }

    //构建WMS的领料申请单
    private HtWmsMtlOutRequestDTO convertMtlMoveRequest(MpInvActivityEntity mpInvActivityEntity){
//        List<MpInvActivityDtlEntity> mpInvActivityDtlList  =  mpInvActivityEntity.getMpInvActivityDtlList();

        List<MpInvActivitySnHtWmsEntity> mpInvActivitySnHtWmsList  =  mpInvActivityEntity.getMpInvActivitySnHtWmsList();

        HtWmsMtlOutRequestDTO htWmsMtlOutRequestDTO = new HtWmsMtlOutRequestDTO();
        HtWmsMtlOutDtlRequestDTO htWmsMtlOutDtlRequestDTO = new HtWmsMtlOutDtlRequestDTO();


        //对照转换
        htWmsMtlOutDtlRequestDTO.setId(mpInvActivityEntity.getOrderNo());
        //调拨申请单ID,传入其他系统的单据ID，不可重复
//        Random random = new Random();
//        int randomNumber = random.nextInt(900) + 100;

        htWmsMtlOutDtlRequestDTO.setCCode(mpInvActivityEntity.getOrderNo());
        htWmsMtlOutDtlRequestDTO.setDdate(cn.tfinfo.microservice.common.utils.DateUtils.dateToStr(mpInvActivityEntity.getActivityTime(), DateConstant.FORMAT_YYYY_MM_DD));
        htWmsMtlOutDtlRequestDTO.setVouchtype("线边仓出库");
        htWmsMtlOutDtlRequestDTO.setWhcode(mpInvActivityEntity.getIssueWarehouse());//调出仓库
        htWmsMtlOutDtlRequestDTO.setDepcode("");//部门

//        htWmsMtlOutDtlRequestDTO.setPersonCode(htWmsLnMtlAlyEntity.getApplicantCode());//人员编码
        //todo  业务人员编码，不存在会卡控
        htWmsMtlOutDtlRequestDTO.setPersonCode("");
        htWmsMtlOutDtlRequestDTO.setSourceCode(mpInvActivityEntity.getOrderCode());
        htWmsMtlOutDtlRequestDTO.setDefine1("");//领料仓库编码
        htWmsMtlOutDtlRequestDTO.setDefine2(mpInvActivityEntity.getOpuserCode());
        htWmsMtlOutDtlRequestDTO.setDefine3(mpInvActivityEntity.getOpuserName());
        htWmsMtlOutDtlRequestDTO.setDefine4("");
        //todo 领料申请单没有该字段
//        htWmsMtlOutDtlRequestDTO.setDeleteMark("");
//        Date now = new Date();
        LocalDate aoTtoday = LocalDate.now(); // 获取当前日期
        htWmsMtlOutDtlRequestDTO.setCreateOn(aoTtoday.toString());
        htWmsMtlOutDtlRequestDTO.setCreateUserId(mpInvActivityEntity.getRelateduserCode());
        htWmsMtlOutDtlRequestDTO.setCreateBy("");
        htWmsMtlOutDtlRequestDTO.setCmemo(mpInvActivityEntity.getRemarks());

        //物料列表
        List<HtWmsMtlOutDtlItemRequestDTO> htWmsMtlOutDtlItemRequestList = new ArrayList<>();

        for (int rowNo=0;rowNo<mpInvActivitySnHtWmsList.size();rowNo++){


            MpInvActivitySnHtWmsEntity mpMtlMoveEntity = mpInvActivitySnHtWmsList.get(rowNo);
            HtWmsMtlOutDtlItemRequestDTO htWmsMtlOutDtlItemRequestDTO = new HtWmsMtlOutDtlItemRequestDTO();


            //物料条码
            htWmsMtlOutDtlItemRequestDTO.setBarcodeNo(mpMtlMoveEntity.getMaterialBarcode());

            htWmsMtlOutDtlItemRequestList.add(htWmsMtlOutDtlItemRequestDTO);


    }


        htWmsMtlOutDtlRequestDTO.setBarcodeList(htWmsMtlOutDtlItemRequestList);
        htWmsMtlOutRequestDTO.setEntity(htWmsMtlOutDtlRequestDTO);
        return htWmsMtlOutRequestDTO;
    }


    //构建WMS的车间退料申请单
    private HtWmsMtlOutRequestDTO convertMtlMoveReturnRequest(MpInvActivityEntity mpInvActivityEntity){
//        List<MpInvActivityDtlEntity> mpInvActivityDtlList  =  mpInvActivityEntity.getMpInvActivityDtlList();

        List<MpInvActivitySnHtWmsEntity> mpInvActivitySnHtWmsList  =  mpInvActivityEntity.getMpInvActivitySnHtWmsList();

        HtWmsMtlOutRequestDTO htWmsMtlOutRequestDTO = new HtWmsMtlOutRequestDTO();
        HtWmsMtlOutDtlRequestDTO htWmsMtlOutDtlRequestDTO = new HtWmsMtlOutDtlRequestDTO();


        //对照转换
        htWmsMtlOutDtlRequestDTO.setId(mpInvActivityEntity.getOrderNo());
        //调拨申请单ID,传入其他系统的单据ID，不可重复
//        Random random = new Random();
//        int randomNumber = random.nextInt(900) + 100;

        htWmsMtlOutDtlRequestDTO.setCCode(mpInvActivityEntity.getOrderNo());
        htWmsMtlOutDtlRequestDTO.setDdate(cn.tfinfo.microservice.common.utils.DateUtils.dateToStr(mpInvActivityEntity.getActivityTime(), DateConstant.FORMAT_YYYY_MM_DD));
        htWmsMtlOutDtlRequestDTO.setVouchtype("线边仓出库");
        htWmsMtlOutDtlRequestDTO.setWhcode(mpInvActivityEntity.getLocationCode());//调出仓库
        htWmsMtlOutDtlRequestDTO.setDepcode("");//部门

//        htWmsMtlOutDtlRequestDTO.setPersonCode(htWmsLnMtlAlyEntity.getApplicantCode());//人员编码
        //todo  业务人员编码，不存在会卡控
        htWmsMtlOutDtlRequestDTO.setPersonCode("");
        htWmsMtlOutDtlRequestDTO.setSourceCode(mpInvActivityEntity.getOrderCode());
        htWmsMtlOutDtlRequestDTO.setDefine1("");//领料仓库编码
        htWmsMtlOutDtlRequestDTO.setDefine2(mpInvActivityEntity.getOpuserCode());
        htWmsMtlOutDtlRequestDTO.setDefine3(mpInvActivityEntity.getOpuserName());
        htWmsMtlOutDtlRequestDTO.setDefine4("");
        //todo 领料申请单没有该字段
//        htWmsMtlOutDtlRequestDTO.setDeleteMark("");
//        Date now = new Date();
        LocalDate aoTtoday = LocalDate.now(); // 获取当前日期
        htWmsMtlOutDtlRequestDTO.setCreateOn(aoTtoday.toString());
        htWmsMtlOutDtlRequestDTO.setCreateUserId(mpInvActivityEntity.getRelateduserCode());
        htWmsMtlOutDtlRequestDTO.setCreateBy("");
        htWmsMtlOutDtlRequestDTO.setCmemo(mpInvActivityEntity.getRemarks());

        //物料列表
        List<HtWmsMtlOutDtlItemRequestDTO> htWmsMtlOutDtlItemRequestList = new ArrayList<>();

        for (int rowNo=0;rowNo<mpInvActivitySnHtWmsList.size();rowNo++){


            MpInvActivitySnHtWmsEntity mpMtlMoveEntity = mpInvActivitySnHtWmsList.get(rowNo);
            HtWmsMtlOutDtlItemRequestDTO htWmsMtlOutDtlItemRequestDTO = new HtWmsMtlOutDtlItemRequestDTO();


            //物料条码
            htWmsMtlOutDtlItemRequestDTO.setBarcodeNo(mpMtlMoveEntity.getMaterialBarcode());

            htWmsMtlOutDtlItemRequestList.add(htWmsMtlOutDtlItemRequestDTO);


        }


        htWmsMtlOutDtlRequestDTO.setBarcodeList(htWmsMtlOutDtlItemRequestList);
        htWmsMtlOutRequestDTO.setEntity(htWmsMtlOutDtlRequestDTO);
        return htWmsMtlOutRequestDTO;
    }



    //查询生产订单的车间领料消耗
    public HtWmsMoveOrderDTO findMoveWmsListByOrder(String orderCode,String opType) {
        HtWmsMoveOrderDTO htWmsMoveOrderDTO= new HtWmsMoveOrderDTO();
        HtOrderInfoEntity htOrderInfoEntity = htOrderInfoDao.queryByNo(orderCode);

        //可能是老MES的订单领料
        if (htOrderInfoEntity == null) {
//            return null;
            htWmsMoveOrderDTO.setOrderCode(orderCode);
            htWmsMoveOrderDTO.setProductQty(0);
            htWmsMoveOrderDTO.setOrderStatus("X");
        }
        else{
            htWmsMoveOrderDTO.setOrderCode(orderCode);
            htWmsMoveOrderDTO.setProductQty(htOrderInfoEntity.getQtyIn());
            htWmsMoveOrderDTO.setOrderStatus(htOrderInfoEntity.getOrderStatus());
        }

        //todo 批次已完成库存

        if(opType.equals("2")){
            //车间领料-累计数量
            List<HtWmsMoveOrderItemDTO> htWmsMoveOrderItemDTOList = mpMtlMoveDao.findMoveWmsListByOrder(orderCode,null);
            htWmsMoveOrderDTO.setMtlList(htWmsMoveOrderItemDTOList);
        }
        else if(opType.equals("1")){
            //线边领料-累计数量
            List<HtWmsLnMtlAlyOrderDEntity> HtWmsLnMtlAlyOrderDEntityList = htWmsLnMtlAlyOrderDao.findHtWmsLnMtlAlyOrderListByOrderCode(orderCode);
            htWmsMoveOrderDTO.setOrderlineMtlList(HtWmsLnMtlAlyOrderDEntityList);
        }




        return htWmsMoveOrderDTO;
    }


    //查询生产订单的车间领料消耗
    public HtWmsMoveInfoDTO findMoveInfoWmsbyMtlGroupNo(String mtlGroupNo, String opType) {
        HtWmsMoveInfoDTO htWmsMoveInfoDTO = mpInvMtlLocDao.findMtlLocBaseByMtlGroupNo(mtlGroupNo);

        if(opType.equals("1")){
            //查询车间领料的对应生产订单号
            MpInvActivityMoveInfoHtWmsDto mpInvActivityMoveInfoHtWmsDto = mpInvActivityDao.findInvActivityByMtlGroupNo(mtlGroupNo);
           if(mpInvActivityMoveInfoHtWmsDto!=null){
               if(htWmsMoveInfoDTO==null){
                   htWmsMoveInfoDTO.setMtlgroupNo(mtlGroupNo);
                   htWmsMoveInfoDTO.setMtlQty("0");
                   htWmsMoveInfoDTO.setMoveOriginQty(mpInvActivityMoveInfoHtWmsDto.getMtlQty());
                   htWmsMoveInfoDTO.setLocationKind(mpInvActivityMoveInfoHtWmsDto.getLocationKind());
                   htWmsMoveInfoDTO.setLocationCode(mpInvActivityMoveInfoHtWmsDto.getLocationCode());
                   htWmsMoveInfoDTO.setLocationId(mpInvActivityMoveInfoHtWmsDto.getLocationId());
                   htWmsMoveInfoDTO.setLocationName(mpInvActivityMoveInfoHtWmsDto.getLocationName());
               }
               htWmsMoveInfoDTO.setMoveOrderCode(mpInvActivityMoveInfoHtWmsDto.getSourceNo());
               htWmsMoveInfoDTO.setMoveOriginQty(mpInvActivityMoveInfoHtWmsDto.getMtlQty());

               //查询是否设备上料
               List<String> mtlgroupNoMesList = new ArrayList<>();
               mtlgroupNoMesList.add(mtlGroupNo);
               HtEqpMtlDTO htEqpMtlDTO = htWmsBaseDao.findEqpMtlByMtlgroupNo(mtlgroupNoMesList);
               if(htEqpMtlDTO!=null){
                   htWmsMoveInfoDTO.setIsEqpMtl("1");
                   htWmsMoveInfoDTO.setEqpCode(htEqpMtlDTO.getEqpCode());
               }
               else{
                   htWmsMoveInfoDTO.setIsEqpMtl("0");
                   htWmsMoveInfoDTO.setEqpCode("");
               }

           }



        }


        if (htWmsMoveInfoDTO == null) {
            return null;
        }

        return htWmsMoveInfoDTO;
    }


    //撤销操作，车间领料，车间退料
    public void deleteMtlMoveNew(String id,  String updateBy) {

        mpInvActivityDao.deleteInvActivity(updateBy,id);
        // 删除物料活动明细数据
        mpInvActivityDtlDao.deleteInvActivityDtlByInvactivityId(id);
        // 删除物料活动序列号数据
        mpInvActivitySnDao.deleteInvActivitySnByInvactivityId(id);

        // WMS物料条码-删除物料活动序列号数据
        mpInvActivitySnHtWmsDao.deleteInvActivitySnHtWmsByInvactivityId(id);
    }




    /**
     * 获取日期加减类型
     *
     * @param paramvalUnit
     * @return
     */
    private int getDateAmount(String paramvalUnit) {
        int result;
        switch (paramvalUnit) {
            case DAY:
                result = Calendar.DATE;
                break;
            case HOUR:
                result = Calendar.HOUR;
                break;
            case MINUTE:
                result = Calendar.MINUTE;
                break;
            default:
                result = Calendar.DATE;
        }
        return result;
    }







}
